diff --git a/packages/@aws-cdk/aws-appsync/.gitignore b/packages/@aws-cdk/aws-appsync/.gitignore index 42cccbde88faa..8c18bc6583957 100644 --- a/packages/@aws-cdk/aws-appsync/.gitignore +++ b/packages/@aws-cdk/aws-appsync/.gitignore @@ -23,3 +23,4 @@ junit.xml !**/*.snapshot/**/asset.*/*.d.ts !**/*.snapshot/**/asset.*/** +!test/integ-assets/**/*.js diff --git a/packages/@aws-cdk/aws-appsync/README.md b/packages/@aws-cdk/aws-appsync/README.md index 79bad874fdd45..bc31b2ca2ece0 100644 --- a/packages/@aws-cdk/aws-appsync/README.md +++ b/packages/@aws-cdk/aws-appsync/README.md @@ -550,4 +550,40 @@ const pipelineResolver = new appsync.Resolver(this, 'pipeline', { }); ``` +### JS Functions and Resolvers + +JS Functions and resolvers are also supported. You can use a `.js` file within your CDK project, or specify your function code inline. + +```ts +declare const api: appsync.GraphqlApi; + +const myJsFunction = new appsync.AppsyncFunction(this, 'function', { + name: 'my_js_function', + api, + dataSource: api.addNoneDataSource('none'), + code: appsync.Code.fromAsset('directory/function_code.js'), + runtime: appsync.FunctionRuntime.JS_1_0_0, +}); + +new appsync.Resolver(this, 'PipelineResolver', { + api, + typeName: 'typeName', + fieldName: 'fieldName', + code: appsync.Code.fromInline(` + // The before step + export function request(...args) { + console.log(args); + return {} + } + + // The after step + export function response(ctx) { + return ctx.prev.result + } + `), + runtime: appsync.FunctionRuntime.JS_1_0_0, + pipelineConfig: [myJsFunction], +}); +``` + Learn more about Pipeline Resolvers and AppSync Functions [here](https://docs.aws.amazon.com/appsync/latest/devguide/pipeline-resolvers.html). diff --git a/packages/@aws-cdk/aws-appsync/lib/appsync-function.ts b/packages/@aws-cdk/aws-appsync/lib/appsync-function.ts index 46019afe6c2a9..1153a3aed85ec 100644 --- a/packages/@aws-cdk/aws-appsync/lib/appsync-function.ts +++ b/packages/@aws-cdk/aws-appsync/lib/appsync-function.ts @@ -1,9 +1,11 @@ import { Resource, IResource, Lazy, Fn } from '@aws-cdk/core'; import { Construct } from 'constructs'; import { CfnFunctionConfiguration } from './appsync.generated'; +import { Code } from './code'; import { BaseDataSource } from './data-source'; import { IGraphqlApi } from './graphqlapi-base'; import { MappingTemplate } from './mapping-template'; +import { FunctionRuntime } from './runtime'; /** * the base properties for AppSync Functions @@ -31,6 +33,18 @@ export interface BaseAppsyncFunctionProps { * @default - no response mapping template */ readonly responseMappingTemplate?: MappingTemplate; + /** + * The functions runtime + * + * @default - no function runtime, VTL mapping templates used + */ + readonly runtime?: FunctionRuntime; + /** + * The function code + * + * @default - no code is used + */ + readonly code?: Code; } /** @@ -128,11 +142,25 @@ export class AppsyncFunction extends Resource implements IAppsyncFunction { public constructor(scope: Construct, id: string, props: AppsyncFunctionProps) { super(scope, id); + + // If runtime is specified, code must also be + if (props.runtime && !props.code) { + throw new Error('Code is required when specifying a runtime'); + } + + if (props.code && (props.requestMappingTemplate || props.responseMappingTemplate)) { + throw new Error('Mapping templates cannot be used alongside code'); + } + + const code = props.code?.bind(this); this.function = new CfnFunctionConfiguration(this, 'Resource', { name: props.name, description: props.description, apiId: props.api.apiId, dataSourceName: props.dataSource.name, + runtime: props.runtime?.toProperties(), + codeS3Location: code?.s3Location, + code: code?.inlineCode, functionVersion: '2018-05-29', requestMappingTemplate: props.requestMappingTemplate?.renderTemplate(), responseMappingTemplate: props.responseMappingTemplate?.renderTemplate(), diff --git a/packages/@aws-cdk/aws-appsync/lib/code.ts b/packages/@aws-cdk/aws-appsync/lib/code.ts new file mode 100644 index 0000000000000..821e166faeb2d --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/lib/code.ts @@ -0,0 +1,98 @@ +import * as s3_assets from '@aws-cdk/aws-s3-assets'; +import * as cdk from '@aws-cdk/core'; +import { Construct } from 'constructs'; + +/** + * Result of binding `Code` into a `Function`. + */ +export interface CodeConfig { + /** + * The location of the code in S3 (mutually exclusive with `inlineCode`. + * @default - code is not an s3 location + */ + readonly s3Location?: string; + + /** + * Inline code (mutually exclusive with `s3Location`). + * @default - code is not inline code + */ + readonly inlineCode?: string; +} + +/** + * Represents source code for an AppSync Function or Resolver. + */ +export abstract class Code { + /** + * Loads the function code from a local disk path. + * + * @param path The path to the source code file. + */ + public static fromAsset(path: string, options?: s3_assets.AssetOptions): AssetCode { + return new AssetCode(path, options); + } + + /** + * Inline code for AppSync function + * @returns `InlineCode` with inline code. + * @param code The actual handler code (limited to 4KiB) + */ + public static fromInline(code: string): InlineCode { + return new InlineCode(code); + } + + /** + * Bind source code to an AppSync Function or resolver. + */ + public abstract bind(scope: Construct): CodeConfig; +} + +/** + * Represents a local file with source code used for an AppSync Function or Resolver. + */ +export class AssetCode extends Code { + private asset?: s3_assets.Asset; + + /** + * @param path The path to the asset file. + */ + constructor(public readonly path: string, private readonly options: s3_assets.AssetOptions = { }) { + super(); + } + + public bind(scope: Construct): CodeConfig { + // If the same AssetCode is used multiple times, retain only the first instantiation. + if (!this.asset) { + this.asset = new s3_assets.Asset(scope, 'Code', { + path: this.path, + ...this.options, + }); + } else if (cdk.Stack.of(this.asset) !== cdk.Stack.of(scope)) { + throw new Error(`Asset is already associated with another stack '${cdk.Stack.of(this.asset).stackName}'. ` + + 'Create a new Code instance for every stack.'); + } + + return { + s3Location: this.asset.s3ObjectUrl, + }; + } +} + +/** + * AppSync function code from an inline string. + */ +export class InlineCode extends Code { + constructor(private code: string) { + super(); + + if (code.length === 0) { + throw new Error('AppSync Inline code cannot be empty'); + } + } + + public bind(_scope: Construct): CodeConfig { + return { + inlineCode: this.code, + }; + } +} diff --git a/packages/@aws-cdk/aws-appsync/lib/index.ts b/packages/@aws-cdk/aws-appsync/lib/index.ts index 70286a0e72748..6237b39e1e0e7 100644 --- a/packages/@aws-cdk/aws-appsync/lib/index.ts +++ b/packages/@aws-cdk/aws-appsync/lib/index.ts @@ -10,3 +10,5 @@ export * from './resolver'; export * from './schema'; export * from './graphqlapi'; export * from './graphqlapi-base'; +export * from './code'; +export * from './runtime'; diff --git a/packages/@aws-cdk/aws-appsync/lib/resolver.ts b/packages/@aws-cdk/aws-appsync/lib/resolver.ts index 72818cb59b966..1c12438fe692d 100644 --- a/packages/@aws-cdk/aws-appsync/lib/resolver.ts +++ b/packages/@aws-cdk/aws-appsync/lib/resolver.ts @@ -4,9 +4,11 @@ import { IAppsyncFunction } from './appsync-function'; import { CfnResolver } from './appsync.generated'; import { CachingConfig } from './caching-config'; import { BASE_CACHING_KEYS } from './caching-key'; +import { Code } from './code'; import { BaseDataSource } from './data-source'; import { IGraphqlApi } from './graphqlapi-base'; import { MappingTemplate } from './mapping-template'; +import { FunctionRuntime } from './runtime'; /** * Basic properties for an AppSync resolver @@ -51,6 +53,19 @@ export interface BaseResolverProps { * @default - No max batch size */ readonly maxBatchSize?: number; + + /** + * The functions runtime + * + * @default - no function runtime, VTL mapping templates used + */ + readonly runtime?: FunctionRuntime; + /** + * The function code + * + * @default - no code is used + */ + readonly code?: Code; } /** @@ -93,6 +108,15 @@ export class Resolver extends Construct { { functions: props.pipelineConfig.map((func) => func.functionId) } : undefined; + // If runtime is specified, code must also be + if (props.runtime && !props.code) { + throw new Error('Code is required when specifying a runtime'); + } + + if (props.code && (props.requestMappingTemplate || props.responseMappingTemplate)) { + throw new Error('Mapping templates cannot be used alongside code'); + } + if (pipelineConfig && props.dataSource) { throw new Error(`Pipeline Resolver cannot have data source. Received: ${props.dataSource.name}`); } @@ -108,12 +132,16 @@ export class Resolver extends Construct { } } + const code = props.code?.bind(this); this.resolver = new CfnResolver(this, 'Resource', { apiId: props.api.apiId, typeName: props.typeName, fieldName: props.fieldName, dataSourceName: props.dataSource ? props.dataSource.name : undefined, kind: pipelineConfig ? 'PIPELINE' : 'UNIT', + runtime: props.runtime?.toProperties(), + codeS3Location: code?.s3Location, + code: code?.inlineCode, pipelineConfig: pipelineConfig, requestMappingTemplate: props.requestMappingTemplate ? props.requestMappingTemplate.renderTemplate() : undefined, responseMappingTemplate: props.responseMappingTemplate ? props.responseMappingTemplate.renderTemplate() : undefined, diff --git a/packages/@aws-cdk/aws-appsync/lib/runtime.ts b/packages/@aws-cdk/aws-appsync/lib/runtime.ts new file mode 100644 index 0000000000000..124f525d17cfb --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/lib/runtime.ts @@ -0,0 +1,60 @@ +/** + * Config for binding runtime to a function or resolver + */ +export interface RuntimeConfig { + /** + * The name of the runtime + */ + readonly name: string; + + /** + * The version string of the runtime + */ + readonly runtimeVersion: string; +} + +/** + * Appsync supported runtimes. Only JavaScript as of now + */ +export enum FunctionRuntimeFamily { + /** + * AppSync JavaScript runtime + */ + JS = 'APPSYNC_JS', +} + +/** + * Utility class for specifying specific appsync runtime versions + */ +export class FunctionRuntime { + /** + * APPSYNC_JS v1.0.0 runtime + */ + public static readonly JS_1_0_0 = new FunctionRuntime(FunctionRuntimeFamily.JS, '1.0.0'); + + /** + * The name of the runtime + */ + public readonly name: string; + + /** + * The runtime version + */ + public readonly version: string; + + public constructor(family: FunctionRuntimeFamily, version: string) { + this.name = family; + this.version = version; + } + + /** + * Convert to Cfn runtime configuration property format + */ + public toProperties(): RuntimeConfig { + return { + name: this.name, + runtimeVersion: this.version, + }; + } +} + diff --git a/packages/@aws-cdk/aws-appsync/package.json b/packages/@aws-cdk/aws-appsync/package.json index b0e9b8c1320d8..b80e94bad4136 100644 --- a/packages/@aws-cdk/aws-appsync/package.json +++ b/packages/@aws-cdk/aws-appsync/package.json @@ -118,6 +118,7 @@ "@aws-cdk/aws-logs": "0.0.0", "@aws-cdk/aws-opensearchservice": "0.0.0", "@aws-cdk/aws-rds": "0.0.0", + "@aws-cdk/assets": "0.0.0", "@aws-cdk/aws-s3-assets": "0.0.0", "@aws-cdk/aws-secretsmanager": "0.0.0", "@aws-cdk/core": "0.0.0", diff --git a/packages/@aws-cdk/aws-appsync/test/appsync.js-resolver.graphql b/packages/@aws-cdk/aws-appsync/test/appsync.js-resolver.graphql new file mode 100644 index 0000000000000..2e29df5c893d2 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/appsync.js-resolver.graphql @@ -0,0 +1,10 @@ +type Test { + id: String! + name: String! +} +type Query { + getTests: [Test]! +} +type Mutation { + addTest(name: String!): Test +} diff --git a/packages/@aws-cdk/aws-appsync/test/integ-assets/appsync-js-pipeline.js b/packages/@aws-cdk/aws-appsync/test/integ-assets/appsync-js-pipeline.js new file mode 100644 index 0000000000000..cfc6716b9273a --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ-assets/appsync-js-pipeline.js @@ -0,0 +1,9 @@ +// The before step +export function request(...args) { + return {} +} + +// The after step +export function response(ctx) { + return ctx.prev.result +} diff --git a/packages/@aws-cdk/aws-appsync/test/integ-assets/appsync-js-resolver.js b/packages/@aws-cdk/aws-appsync/test/integ-assets/appsync-js-resolver.js new file mode 100644 index 0000000000000..74a309765f2c2 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ-assets/appsync-js-resolver.js @@ -0,0 +1,22 @@ +import { util } from '@aws-appsync/utils' + +export function request(ctx) { + const id = util.autoId() + const name = ctx.args.name; + + ctx.args.input = { + id, + name, + } + + return { + version: '2018-05-29', + operation: 'PutItem', + key: { id: util.dynamodb.toDynamoDB(ctx.args.input.id) }, + attributeValues: util.dynamodb.toMapValues(ctx.args.input), + }; +} + +export function response(ctx) { + return ctx.result; +} diff --git a/packages/@aws-cdk/aws-appsync/test/integ-assets/js-resolver-assertion/index.js b/packages/@aws-cdk/aws-appsync/test/integ-assets/js-resolver-assertion/index.js new file mode 100644 index 0000000000000..db0dbed85dfd5 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ-assets/js-resolver-assertion/index.js @@ -0,0 +1,24 @@ +exports.handler = async function(event) { + console.log(event); + + let myHeaders = new Headers(); + myHeaders.append("x-api-key", event.apiKey); + myHeaders.append("Content-Type", "application/json"); + + const query = JSON.stringify({ + query: "mutation MyMutation {\n addTest(name: \"123\") {\n id\n name\n }\n}", + variables: {} + }); + + const requestOptions = { + method: 'POST', + headers: myHeaders, + body: query, + redirect: 'follow' + }; + + const response = await fetch(event.hostname, requestOptions) + .then(response => response.json()) + + return response; +} diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/AppSyncJsResolverTestStack.assets.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/AppSyncJsResolverTestStack.assets.json new file mode 100644 index 0000000000000..752b981f93838 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/AppSyncJsResolverTestStack.assets.json @@ -0,0 +1,71 @@ +{ + "version": "22.0.0", + "files": { + "d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347": { + "source": { + "path": "asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347", + "packaging": "zip" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347.zip", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + }, + "64f136fd66d0a20e8574eddfe2e50aa10168344ebac0f3ca03e5ae0b4b7475ec": { + "source": { + "path": "asset.64f136fd66d0a20e8574eddfe2e50aa10168344ebac0f3ca03e5ae0b4b7475ec.js", + "packaging": "file" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "64f136fd66d0a20e8574eddfe2e50aa10168344ebac0f3ca03e5ae0b4b7475ec.js", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + }, + "922ddc9d9563ca9402e283efe80ad2b4e00c8ddf6fbbbc2ae2b9dc6fe7107061": { + "source": { + "path": "asset.922ddc9d9563ca9402e283efe80ad2b4e00c8ddf6fbbbc2ae2b9dc6fe7107061.js", + "packaging": "file" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "922ddc9d9563ca9402e283efe80ad2b4e00c8ddf6fbbbc2ae2b9dc6fe7107061.js", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + }, + "c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a": { + "source": { + "path": "asset.c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a", + "packaging": "zip" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a.zip", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + }, + "e8854d9a08f981fd59e6f71b86e4266fb80f578b9f7edd5cce794f4f302404e7": { + "source": { + "path": "AppSyncJsResolverTestStack.template.json", + "packaging": "file" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "e8854d9a08f981fd59e6f71b86e4266fb80f578b9f7edd5cce794f4f302404e7.json", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + } + }, + "dockerImages": {} +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/AppSyncJsResolverTestStack.template.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/AppSyncJsResolverTestStack.template.json new file mode 100644 index 0000000000000..51426b563189a --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/AppSyncJsResolverTestStack.template.json @@ -0,0 +1,478 @@ +{ + "Resources": { + "JsResolverApiApiLogsRoleAA94FCF2": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "appsync.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSAppSyncPushToCloudWatchLogs" + ] + ] + } + ] + } + }, + "JsResolverApi612CD442": { + "Type": "AWS::AppSync::GraphQLApi", + "Properties": { + "AuthenticationType": "API_KEY", + "Name": "JsResolverApi", + "LogConfig": { + "CloudWatchLogsRoleArn": { + "Fn::GetAtt": [ + "JsResolverApiApiLogsRoleAA94FCF2", + "Arn" + ] + }, + "FieldLogLevel": "NONE" + } + } + }, + "JsResolverApiSchema1CF261C1": { + "Type": "AWS::AppSync::GraphQLSchema", + "Properties": { + "ApiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "Definition": "type Test {\n id: String!\n name: String!\n}\ntype Query {\n getTests: [Test]!\n}\ntype Mutation {\n addTest(name: String!): Test\n}\n" + } + }, + "JsResolverApiDefaultApiKeyBD458F31": { + "Type": "AWS::AppSync::ApiKey", + "Properties": { + "ApiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + } + }, + "DependsOn": [ + "JsResolverApiSchema1CF261C1" + ] + }, + "JsResolverApiLogRetention66DE3830": { + "Type": "Custom::LogRetention", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aFD4BFC8A", + "Arn" + ] + }, + "LogGroupName": { + "Fn::Join": [ + "", + [ + "/aws/appsync/apis/", + { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + } + ] + ] + }, + "RetentionInDays": 7 + } + }, + "JsResolverApiDynamoDataSourceServiceRole6406F7E8": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "appsync.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + } + } + }, + "JsResolverApiDynamoDataSourceServiceRoleDefaultPolicy44BA5FB6": { + "Type": "AWS::IAM::Policy", + "Properties": { + "PolicyDocument": { + "Statement": [ + { + "Action": [ + "dynamodb:BatchGetItem", + "dynamodb:BatchWriteItem", + "dynamodb:ConditionCheckItem", + "dynamodb:DeleteItem", + "dynamodb:DescribeTable", + "dynamodb:GetItem", + "dynamodb:GetRecords", + "dynamodb:GetShardIterator", + "dynamodb:PutItem", + "dynamodb:Query", + "dynamodb:Scan", + "dynamodb:UpdateItem" + ], + "Effect": "Allow", + "Resource": [ + { + "Fn::GetAtt": [ + "DynamoTableB2B22E15", + "Arn" + ] + }, + { + "Ref": "AWS::NoValue" + } + ] + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "JsResolverApiDynamoDataSourceServiceRoleDefaultPolicy44BA5FB6", + "Roles": [ + { + "Ref": "JsResolverApiDynamoDataSourceServiceRole6406F7E8" + } + ] + } + }, + "JsResolverApiDynamoDataSource58CF75DE": { + "Type": "AWS::AppSync::DataSource", + "Properties": { + "ApiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "Name": "DynamoDataSource", + "Type": "AMAZON_DYNAMODB", + "DynamoDBConfig": { + "AwsRegion": { + "Ref": "AWS::Region" + }, + "TableName": { + "Ref": "DynamoTableB2B22E15" + } + }, + "ServiceRoleArn": { + "Fn::GetAtt": [ + "JsResolverApiDynamoDataSourceServiceRole6406F7E8", + "Arn" + ] + } + } + }, + "JsResolverApiAddTestFunction76B4557F": { + "Type": "AWS::AppSync::FunctionConfiguration", + "Properties": { + "ApiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "DataSourceName": "DynamoDataSource", + "Name": "addTestFunc", + "CodeS3Location": { + "Fn::Sub": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/64f136fd66d0a20e8574eddfe2e50aa10168344ebac0f3ca03e5ae0b4b7475ec.js" + }, + "FunctionVersion": "2018-05-29", + "Runtime": { + "Name": "APPSYNC_JS", + "RuntimeVersion": "1.0.0" + } + }, + "DependsOn": [ + "JsResolverApiDynamoDataSource58CF75DE", + "JsResolverApiSchema1CF261C1" + ] + }, + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRole9741ECFB": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + ] + ] + } + ] + } + }, + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRoleDefaultPolicyADDA7DEB": { + "Type": "AWS::IAM::Policy", + "Properties": { + "PolicyDocument": { + "Statement": [ + { + "Action": [ + "logs:DeleteRetentionPolicy", + "logs:PutRetentionPolicy" + ], + "Effect": "Allow", + "Resource": "*" + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRoleDefaultPolicyADDA7DEB", + "Roles": [ + { + "Ref": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRole9741ECFB" + } + ] + } + }, + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aFD4BFC8A": { + "Type": "AWS::Lambda::Function", + "Properties": { + "Handler": "index.handler", + "Runtime": "nodejs14.x", + "Code": { + "S3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" + }, + "S3Key": "d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347.zip" + }, + "Role": { + "Fn::GetAtt": [ + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRole9741ECFB", + "Arn" + ] + } + }, + "DependsOn": [ + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRoleDefaultPolicyADDA7DEB", + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRole9741ECFB" + ] + }, + "DynamoTableB2B22E15": { + "Type": "AWS::DynamoDB::Table", + "Properties": { + "KeySchema": [ + { + "AttributeName": "id", + "KeyType": "HASH" + } + ], + "AttributeDefinitions": [ + { + "AttributeName": "id", + "AttributeType": "S" + } + ], + "ProvisionedThroughput": { + "ReadCapacityUnits": 5, + "WriteCapacityUnits": 5 + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "AddTestResolver8AF95A30": { + "Type": "AWS::AppSync::Resolver", + "Properties": { + "ApiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "FieldName": "addTest", + "TypeName": "Mutation", + "CodeS3Location": { + "Fn::Sub": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/922ddc9d9563ca9402e283efe80ad2b4e00c8ddf6fbbbc2ae2b9dc6fe7107061.js" + }, + "Kind": "PIPELINE", + "PipelineConfig": { + "Functions": [ + { + "Fn::GetAtt": [ + "JsResolverApiAddTestFunction76B4557F", + "FunctionId" + ] + } + ] + }, + "Runtime": { + "Name": "APPSYNC_JS", + "RuntimeVersion": "1.0.0" + } + }, + "DependsOn": [ + "JsResolverApiSchema1CF261C1" + ] + }, + "InvokeApiServiceRoleFB17CD97": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + ] + ] + } + ] + } + }, + "InvokeApi313C8B49": { + "Type": "AWS::Lambda::Function", + "Properties": { + "Code": { + "S3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" + }, + "S3Key": "c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a.zip" + }, + "Role": { + "Fn::GetAtt": [ + "InvokeApiServiceRoleFB17CD97", + "Arn" + ] + }, + "Handler": "index.handler", + "Runtime": "nodejs18.x" + }, + "DependsOn": [ + "InvokeApiServiceRoleFB17CD97" + ] + } + }, + "Outputs": { + "ExportsOutputRefInvokeApi313C8B4949AC2AFC": { + "Value": { + "Ref": "InvokeApi313C8B49" + }, + "Export": { + "Name": "AppSyncJsResolverTestStack:ExportsOutputRefInvokeApi313C8B4949AC2AFC" + } + }, + "ExportsOutputFnGetAttJsResolverApi612CD442GraphQLUrl15495788": { + "Value": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "GraphQLUrl" + ] + }, + "Export": { + "Name": "AppSyncJsResolverTestStack:ExportsOutputFnGetAttJsResolverApi612CD442GraphQLUrl15495788" + } + }, + "ExportsOutputFnGetAttJsResolverApiDefaultApiKeyBD458F31ApiKey4D429933": { + "Value": { + "Fn::GetAtt": [ + "JsResolverApiDefaultApiKeyBD458F31", + "ApiKey" + ] + }, + "Export": { + "Name": "AppSyncJsResolverTestStack:ExportsOutputFnGetAttJsResolverApiDefaultApiKeyBD458F31ApiKey4D429933" + } + }, + "ExportsOutputRefDynamoTableB2B22E1592AFC2EE": { + "Value": { + "Ref": "DynamoTableB2B22E15" + }, + "Export": { + "Name": "AppSyncJsResolverTestStack:ExportsOutputRefDynamoTableB2B22E1592AFC2EE" + } + } + }, + "Parameters": { + "BootstrapVersion": { + "Type": "AWS::SSM::Parameter::Value", + "Default": "/cdk-bootstrap/hnb659fds/version", + "Description": "Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]" + } + }, + "Rules": { + "CheckBootstrapVersion": { + "Assertions": [ + { + "Assert": { + "Fn::Not": [ + { + "Fn::Contains": [ + [ + "1", + "2", + "3", + "4", + "5" + ], + { + "Ref": "BootstrapVersion" + } + ] + } + ] + }, + "AssertDescription": "CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI." + } + ] + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets.json new file mode 100644 index 0000000000000..f7ca8d6b7a636 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets.json @@ -0,0 +1,32 @@ +{ + "version": "22.0.0", + "files": { + "278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4": { + "source": { + "path": "asset.278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4.bundle", + "packaging": "zip" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4.zip", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + }, + "c9a130d7c2610c9af13d14efb06865c2d07c3a490c0a67ad7fd335b68dabe3e3": { + "source": { + "path": "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.template.json", + "packaging": "file" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "c9a130d7c2610c9af13d14efb06865c2d07c3a490c0a67ad7fd335b68dabe3e3.json", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + } + }, + "dockerImages": {} +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.template.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.template.json new file mode 100644 index 0000000000000..91afb9c04d0a5 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.template.json @@ -0,0 +1,262 @@ +{ + "Resources": { + "LambdaInvokeb55e453397dded0a19101717f7183064": { + "Type": "Custom::DeployAssert@SdkCallLambdainvoke", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F", + "Arn" + ] + }, + "service": "Lambda", + "api": "invoke", + "expected": "{\"$StringLike\":\".+\"}", + "actualPath": "Payload.data.addTest.id", + "parameters": { + "FunctionName": { + "Fn::ImportValue": "AppSyncJsResolverTestStack:ExportsOutputRefInvokeApi313C8B4949AC2AFC" + }, + "Payload": { + "Fn::Join": [ + "", + [ + "{\"hostname\":\"", + { + "Fn::ImportValue": "AppSyncJsResolverTestStack:ExportsOutputFnGetAttJsResolverApi612CD442GraphQLUrl15495788" + }, + "\",\"apiKey\":\"", + { + "Fn::ImportValue": "AppSyncJsResolverTestStack:ExportsOutputFnGetAttJsResolverApiDefaultApiKeyBD458F31ApiKey4D429933" + }, + "\"}" + ] + ] + } + }, + "flattenResponse": "true", + "outputPaths": [ + "Payload.data.addTest.id" + ], + "salt": "1672953452085" + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "LambdaInvokeb55e453397dded0a19101717f7183064InvokeF9C77644": { + "Type": "AWS::Lambda::Permission", + "Properties": { + "Action": "lambda:InvokeFunction", + "FunctionName": { + "Fn::ImportValue": "AppSyncJsResolverTestStack:ExportsOutputRefInvokeApi313C8B4949AC2AFC" + }, + "Principal": { + "Fn::GetAtt": [ + "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73", + "Arn" + ] + } + } + }, + "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Version": "2012-10-17", + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ] + }, + "ManagedPolicyArns": [ + { + "Fn::Sub": "arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + } + ], + "Policies": [ + { + "PolicyName": "Inline", + "PolicyDocument": { + "Version": "2012-10-17", + "Statement": [ + { + "Action": [ + "lambda:Invoke" + ], + "Effect": "Allow", + "Resource": [ + "*" + ] + }, + { + "Action": [ + "lambda:InvokeFunction" + ], + "Effect": "Allow", + "Resource": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":lambda:", + { + "Ref": "AWS::Region" + }, + ":", + { + "Ref": "AWS::AccountId" + }, + ":function:", + { + "Fn::ImportValue": "AppSyncJsResolverTestStack:ExportsOutputRefInvokeApi313C8B4949AC2AFC" + } + ] + ] + } + ] + }, + { + "Action": [ + "dynamodb:GetItem" + ], + "Effect": "Allow", + "Resource": [ + "*" + ] + } + ] + } + } + ] + } + }, + "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F": { + "Type": "AWS::Lambda::Function", + "Properties": { + "Runtime": "nodejs14.x", + "Code": { + "S3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" + }, + "S3Key": "278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4.zip" + }, + "Timeout": 120, + "Handler": "index.handler", + "Role": { + "Fn::GetAtt": [ + "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73", + "Arn" + ] + } + } + }, + "AwsApiCallDynamoDBgetItem": { + "Type": "Custom::DeployAssert@SdkCallDynamoDBgetItem", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F", + "Arn" + ] + }, + "service": "DynamoDB", + "api": "getItem", + "expected": { + "Fn::Join": [ + "", + [ + "{\"$ObjectLike\":{\"Item\":{\"name\":{\"S\":\"123\"},\"id\":{\"S\":\"", + { + "Fn::GetAtt": [ + "LambdaInvokeb55e453397dded0a19101717f7183064", + "apiCallResponse.Payload.data.addTest.id" + ] + }, + "\"}}}}" + ] + ] + }, + "parameters": { + "TableName": { + "Fn::ImportValue": "AppSyncJsResolverTestStack:ExportsOutputRefDynamoTableB2B22E1592AFC2EE" + }, + "Key": { + "id": { + "S": { + "Fn::GetAtt": [ + "LambdaInvokeb55e453397dded0a19101717f7183064", + "apiCallResponse.Payload.data.addTest.id" + ] + } + } + } + }, + "flattenResponse": "false", + "salt": "1672953452086" + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + } + }, + "Outputs": { + "AssertionResultsLambdaInvokeb55e453397dded0a19101717f7183064": { + "Value": { + "Fn::GetAtt": [ + "LambdaInvokeb55e453397dded0a19101717f7183064", + "assertion" + ] + } + }, + "AssertionResultsAwsApiCallDynamoDBgetItem": { + "Value": { + "Fn::GetAtt": [ + "AwsApiCallDynamoDBgetItem", + "assertion" + ] + } + } + }, + "Parameters": { + "BootstrapVersion": { + "Type": "AWS::SSM::Parameter::Value", + "Default": "/cdk-bootstrap/hnb659fds/version", + "Description": "Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]" + } + }, + "Rules": { + "CheckBootstrapVersion": { + "Assertions": [ + { + "Assert": { + "Fn::Not": [ + { + "Fn::Contains": [ + [ + "1", + "2", + "3", + "4", + "5" + ], + { + "Ref": "BootstrapVersion" + } + ] + } + ] + }, + "AssertDescription": "CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI." + } + ] + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4.bundle/index.js b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4.bundle/index.js new file mode 100644 index 0000000000000..2bf09d6726a42 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.278d42fa865f60954d898636503d0ee86a6689d73dc50eb912fac62def0ef6a4.bundle/index.js @@ -0,0 +1,1052 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// lib/assertions/providers/lambda-handler/index.ts +var lambda_handler_exports = {}; +__export(lambda_handler_exports, { + handler: () => handler, + isComplete: () => isComplete, + onTimeout: () => onTimeout +}); +module.exports = __toCommonJS(lambda_handler_exports); + +// ../assertions/lib/matcher.ts +var Matcher = class { + static isMatcher(x) { + return x && x instanceof Matcher; + } +}; +var MatchResult = class { + constructor(target) { + this.failuresHere = /* @__PURE__ */ new Map(); + this.captures = /* @__PURE__ */ new Map(); + this.finalized = false; + this.innerMatchFailures = /* @__PURE__ */ new Map(); + this._hasFailed = false; + this._failCount = 0; + this._cost = 0; + this.target = target; + } + push(matcher, path, message) { + return this.recordFailure({ matcher, path, message }); + } + recordFailure(failure) { + const failKey = failure.path.join("."); + let list = this.failuresHere.get(failKey); + if (!list) { + list = []; + this.failuresHere.set(failKey, list); + } + this._failCount += 1; + this._cost += failure.cost ?? 1; + list.push(failure); + this._hasFailed = true; + return this; + } + get isSuccess() { + return !this._hasFailed; + } + hasFailed() { + return this._hasFailed; + } + get failCount() { + return this._failCount; + } + get failCost() { + return this._cost; + } + compose(id, inner) { + if (inner.hasFailed()) { + this._hasFailed = true; + this._failCount += inner.failCount; + this._cost += inner._cost; + this.innerMatchFailures.set(id, inner); + } + inner.captures.forEach((vals, capture) => { + vals.forEach((value) => this.recordCapture({ capture, value })); + }); + return this; + } + finished() { + if (this.finalized) { + return this; + } + if (this.failCount === 0) { + this.captures.forEach((vals, cap) => cap._captured.push(...vals)); + } + this.finalized = true; + return this; + } + toHumanStrings() { + const failures = new Array(); + debugger; + recurse(this, []); + return failures.map((r) => { + const loc = r.path.length === 0 ? "" : ` at /${r.path.join("/")}`; + return "" + r.message + loc + ` (using ${r.matcher.name} matcher)`; + }); + function recurse(x, prefix) { + for (const fail of Array.from(x.failuresHere.values()).flat()) { + failures.push({ + matcher: fail.matcher, + message: fail.message, + path: [...prefix, ...fail.path] + }); + } + for (const [key, inner] of x.innerMatchFailures.entries()) { + recurse(inner, [...prefix, key]); + } + } + } + renderMismatch() { + if (!this.hasFailed()) { + return ""; + } + const parts = new Array(); + const indents = new Array(); + emitFailures(this, ""); + recurse(this); + return moveMarkersToFront(parts.join("").trimEnd()); + function emit(x) { + if (x === void 0) { + debugger; + } + parts.push(x.replace(/\n/g, ` +${indents.join("")}`)); + } + function emitFailures(r, path, scrapSet) { + for (const fail of r.failuresHere.get(path) ?? []) { + emit(`!! ${fail.message} +`); + } + scrapSet == null ? void 0 : scrapSet.delete(path); + } + function recurse(r) { + const remainingFailures = new Set(Array.from(r.failuresHere.keys()).filter((x) => x !== "")); + if (Array.isArray(r.target)) { + indents.push(" "); + emit("[\n"); + for (const [first, i] of enumFirst(range(r.target.length))) { + if (!first) { + emit(",\n"); + } + emitFailures(r, `${i}`, remainingFailures); + const innerMatcher = r.innerMatchFailures.get(`${i}`); + if (innerMatcher) { + emitFailures(innerMatcher, ""); + recurseComparingValues(innerMatcher, r.target[i]); + } else { + emit(renderAbridged(r.target[i])); + } + } + emitRemaining(); + indents.pop(); + emit("\n]"); + return; + } + if (r.target && typeof r.target === "object") { + indents.push(" "); + emit("{\n"); + const keys = Array.from(/* @__PURE__ */ new Set([ + ...Object.keys(r.target), + ...Array.from(remainingFailures) + ])).sort(); + for (const [first, key] of enumFirst(keys)) { + if (!first) { + emit(",\n"); + } + emitFailures(r, key, remainingFailures); + const innerMatcher = r.innerMatchFailures.get(key); + if (innerMatcher) { + emitFailures(innerMatcher, ""); + emit(`${jsonify(key)}: `); + recurseComparingValues(innerMatcher, r.target[key]); + } else { + emit(`${jsonify(key)}: `); + emit(renderAbridged(r.target[key])); + } + } + emitRemaining(); + indents.pop(); + emit("\n}"); + return; + } + emitRemaining(); + emit(jsonify(r.target)); + function emitRemaining() { + if (remainingFailures.size > 0) { + emit("\n"); + } + for (const key of remainingFailures) { + emitFailures(r, key); + } + } + } + function recurseComparingValues(inner, actualValue) { + if (inner.target === actualValue) { + return recurse(inner); + } + emit(renderAbridged(actualValue)); + emit(" <*> "); + recurse(inner); + } + function renderAbridged(x) { + if (Array.isArray(x)) { + switch (x.length) { + case 0: + return "[]"; + case 1: + return `[ ${renderAbridged(x[0])} ]`; + case 2: + if (x.every((e) => ["number", "boolean", "string"].includes(typeof e))) { + return `[ ${x.map(renderAbridged).join(", ")} ]`; + } + return "[ ... ]"; + default: + return "[ ... ]"; + } + } + if (x && typeof x === "object") { + const keys = Object.keys(x); + switch (keys.length) { + case 0: + return "{}"; + case 1: + return `{ ${JSON.stringify(keys[0])}: ${renderAbridged(x[keys[0]])} }`; + default: + return "{ ... }"; + } + } + return jsonify(x); + } + function jsonify(x) { + return JSON.stringify(x) ?? "undefined"; + } + function moveMarkersToFront(x) { + const re = /^(\s+)!!/gm; + return x.replace(re, (_, spaces) => `!!${spaces.substring(0, spaces.length - 2)}`); + } + } + recordCapture(options) { + let values = this.captures.get(options.capture); + if (values === void 0) { + values = []; + } + values.push(options.value); + this.captures.set(options.capture, values); + } +}; +function* range(n) { + for (let i = 0; i < n; i++) { + yield i; + } +} +function* enumFirst(xs) { + let first = true; + for (const x of xs) { + yield [first, x]; + first = false; + } +} + +// ../assertions/lib/private/matchers/absent.ts +var AbsentMatch = class extends Matcher { + constructor(name) { + super(); + this.name = name; + } + test(actual) { + const result = new MatchResult(actual); + if (actual !== void 0) { + result.recordFailure({ + matcher: this, + path: [], + message: `Received ${actual}, but key should be absent` + }); + } + return result; + } +}; + +// ../assertions/lib/private/sorting.ts +function sortKeyComparator(keyFn) { + return (a, b) => { + const ak = keyFn(a); + const bk = keyFn(b); + for (let i = 0; i < ak.length && i < bk.length; i++) { + const av = ak[i]; + const bv = bk[i]; + let diff = 0; + if (typeof av === "number" && typeof bv === "number") { + diff = av - bv; + } else if (typeof av === "string" && typeof bv === "string") { + diff = av.localeCompare(bv); + } + if (diff !== 0) { + return diff; + } + } + return bk.length - ak.length; + }; +} + +// ../assertions/lib/private/sparse-matrix.ts +var SparseMatrix = class { + constructor() { + this.matrix = /* @__PURE__ */ new Map(); + } + get(row, col) { + var _a; + return (_a = this.matrix.get(row)) == null ? void 0 : _a.get(col); + } + row(row) { + var _a; + return Array.from(((_a = this.matrix.get(row)) == null ? void 0 : _a.entries()) ?? []); + } + set(row, col, value) { + let r = this.matrix.get(row); + if (!r) { + r = /* @__PURE__ */ new Map(); + this.matrix.set(row, r); + } + r.set(col, value); + } +}; + +// ../assertions/lib/private/type.ts +function getType(obj) { + return Array.isArray(obj) ? "array" : typeof obj; +} + +// ../assertions/lib/match.ts +var Match = class { + static absent() { + return new AbsentMatch("absent"); + } + static arrayWith(pattern) { + return new ArrayMatch("arrayWith", pattern); + } + static arrayEquals(pattern) { + return new ArrayMatch("arrayEquals", pattern, { subsequence: false }); + } + static exact(pattern) { + return new LiteralMatch("exact", pattern, { partialObjects: false }); + } + static objectLike(pattern) { + return new ObjectMatch("objectLike", pattern); + } + static objectEquals(pattern) { + return new ObjectMatch("objectEquals", pattern, { partial: false }); + } + static not(pattern) { + return new NotMatch("not", pattern); + } + static serializedJson(pattern) { + return new SerializedJson("serializedJson", pattern); + } + static anyValue() { + return new AnyMatch("anyValue"); + } + static stringLikeRegexp(pattern) { + return new StringLikeRegexpMatch("stringLikeRegexp", pattern); + } +}; +var LiteralMatch = class extends Matcher { + constructor(name, pattern, options = {}) { + super(); + this.name = name; + this.pattern = pattern; + this.partialObjects = options.partialObjects ?? false; + if (Matcher.isMatcher(this.pattern)) { + throw new Error("LiteralMatch cannot directly contain another matcher. Remove the top-level matcher or nest it more deeply."); + } + } + test(actual) { + if (Array.isArray(this.pattern)) { + return new ArrayMatch(this.name, this.pattern, { subsequence: false, partialObjects: this.partialObjects }).test(actual); + } + if (typeof this.pattern === "object") { + return new ObjectMatch(this.name, this.pattern, { partial: this.partialObjects }).test(actual); + } + const result = new MatchResult(actual); + if (typeof this.pattern !== typeof actual) { + result.recordFailure({ + matcher: this, + path: [], + message: `Expected type ${typeof this.pattern} but received ${getType(actual)}` + }); + return result; + } + if (actual !== this.pattern) { + result.recordFailure({ + matcher: this, + path: [], + message: `Expected ${this.pattern} but received ${actual}` + }); + } + return result; + } +}; +var ArrayMatch = class extends Matcher { + constructor(name, pattern, options = {}) { + super(); + this.name = name; + this.pattern = pattern; + this.subsequence = options.subsequence ?? true; + this.partialObjects = options.partialObjects ?? false; + } + test(actual) { + if (!Array.isArray(actual)) { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Expected type array but received ${getType(actual)}` + }); + } + return this.subsequence ? this.testSubsequence(actual) : this.testFullArray(actual); + } + testFullArray(actual) { + const result = new MatchResult(actual); + let i = 0; + for (; i < this.pattern.length && i < actual.length; i++) { + const patternElement = this.pattern[i]; + const matcher = Matcher.isMatcher(patternElement) ? patternElement : new LiteralMatch(this.name, patternElement, { partialObjects: this.partialObjects }); + const innerResult = matcher.test(actual[i]); + result.compose(`${i}`, innerResult); + } + if (i < this.pattern.length) { + result.recordFailure({ + matcher: this, + message: `Not enough elements in array (expecting ${this.pattern.length}, got ${actual.length})`, + path: [`${i}`] + }); + } + if (i < actual.length) { + result.recordFailure({ + matcher: this, + message: `Too many elements in array (expecting ${this.pattern.length}, got ${actual.length})`, + path: [`${i}`] + }); + } + return result; + } + testSubsequence(actual) { + const result = new MatchResult(actual); + let patternIdx = 0; + let actualIdx = 0; + const matches = new SparseMatrix(); + while (patternIdx < this.pattern.length && actualIdx < actual.length) { + const patternElement = this.pattern[patternIdx]; + const matcher = Matcher.isMatcher(patternElement) ? patternElement : new LiteralMatch(this.name, patternElement, { partialObjects: this.partialObjects }); + const matcherName = matcher.name; + if (matcherName == "absent" || matcherName == "anyValue") { + throw new Error(`The Matcher ${matcherName}() cannot be nested within arrayWith()`); + } + const innerResult = matcher.test(actual[actualIdx]); + matches.set(patternIdx, actualIdx, innerResult); + actualIdx++; + if (innerResult.isSuccess) { + result.compose(`${actualIdx}`, innerResult); + patternIdx++; + } + } + if (patternIdx < this.pattern.length) { + for (let spi = 0; spi < patternIdx; spi++) { + const foundMatch = matches.row(spi).find(([, r]) => r.isSuccess); + if (!foundMatch) { + continue; + } + const [index] = foundMatch; + result.compose(`${index}`, new MatchResult(actual[index]).recordFailure({ + matcher: this, + message: `arrayWith pattern ${spi} matched here`, + path: [], + cost: 0 + })); + } + const failedMatches = matches.row(patternIdx); + failedMatches.sort(sortKeyComparator(([i, r]) => [r.failCost, i])); + if (failedMatches.length > 0) { + const [index, innerResult] = failedMatches[0]; + result.recordFailure({ + matcher: this, + message: `Could not match arrayWith pattern ${patternIdx}. This is the closest match`, + path: [`${index}`], + cost: 0 + }); + result.compose(`${index}`, innerResult); + } else { + result.recordFailure({ + matcher: this, + message: `Could not match arrayWith pattern ${patternIdx}. No more elements to try`, + path: [`${actual.length}`] + }); + } + } + return result; + } +}; +var ObjectMatch = class extends Matcher { + constructor(name, pattern, options = {}) { + super(); + this.name = name; + this.pattern = pattern; + this.partial = options.partial ?? true; + } + test(actual) { + if (typeof actual !== "object" || Array.isArray(actual)) { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Expected type object but received ${getType(actual)}` + }); + } + const result = new MatchResult(actual); + if (!this.partial) { + for (const a of Object.keys(actual)) { + if (!(a in this.pattern)) { + result.recordFailure({ + matcher: this, + path: [a], + message: `Unexpected key ${a}` + }); + } + } + } + for (const [patternKey, patternVal] of Object.entries(this.pattern)) { + if (!(patternKey in actual) && !(patternVal instanceof AbsentMatch)) { + result.recordFailure({ + matcher: this, + path: [patternKey], + message: `Missing key '${patternKey}'` + }); + continue; + } + const matcher = Matcher.isMatcher(patternVal) ? patternVal : new LiteralMatch(this.name, patternVal, { partialObjects: this.partial }); + const inner = matcher.test(actual[patternKey]); + result.compose(patternKey, inner); + } + return result; + } +}; +var SerializedJson = class extends Matcher { + constructor(name, pattern) { + super(); + this.name = name; + this.pattern = pattern; + } + test(actual) { + if (getType(actual) !== "string") { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Expected JSON as a string but found ${getType(actual)}` + }); + } + let parsed; + try { + parsed = JSON.parse(actual); + } catch (err) { + if (err instanceof SyntaxError) { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Invalid JSON string: ${actual}` + }); + } else { + throw err; + } + } + const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern); + const innerResult = matcher.test(parsed); + if (innerResult.hasFailed()) { + innerResult.recordFailure({ + matcher: this, + path: [], + message: "Encoded JSON value does not match" + }); + } + return innerResult; + } +}; +var NotMatch = class extends Matcher { + constructor(name, pattern) { + super(); + this.name = name; + this.pattern = pattern; + } + test(actual) { + const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern); + const innerResult = matcher.test(actual); + const result = new MatchResult(actual); + if (innerResult.failCount === 0) { + result.recordFailure({ + matcher: this, + path: [], + message: `Found unexpected match: ${JSON.stringify(actual, void 0, 2)}` + }); + } + return result; + } +}; +var AnyMatch = class extends Matcher { + constructor(name) { + super(); + this.name = name; + } + test(actual) { + const result = new MatchResult(actual); + if (actual == null) { + result.recordFailure({ + matcher: this, + path: [], + message: "Expected a value but found none" + }); + } + return result; + } +}; +var StringLikeRegexpMatch = class extends Matcher { + constructor(name, pattern) { + super(); + this.name = name; + this.pattern = pattern; + } + test(actual) { + const result = new MatchResult(actual); + const regex = new RegExp(this.pattern, "gm"); + if (typeof actual !== "string") { + result.recordFailure({ + matcher: this, + path: [], + message: `Expected a string, but got '${typeof actual}'` + }); + } + if (!regex.test(actual)) { + result.recordFailure({ + matcher: this, + path: [], + message: `String '${actual}' did not match pattern '${this.pattern}'` + }); + } + return result; + } +}; + +// lib/assertions/providers/lambda-handler/base.ts +var https = __toESM(require("https")); +var url = __toESM(require("url")); +var AWS = __toESM(require("aws-sdk")); +var CustomResourceHandler = class { + constructor(event, context) { + this.event = event; + this.context = context; + this.timedOut = false; + this.timeout = setTimeout(async () => { + await this.respond({ + status: "FAILED", + reason: "Lambda Function Timeout", + data: this.context.logStreamName + }); + this.timedOut = true; + }, context.getRemainingTimeInMillis() - 1200); + this.event = event; + this.physicalResourceId = extractPhysicalResourceId(event); + } + async handle() { + try { + if ("stateMachineArn" in this.event.ResourceProperties) { + const req = { + stateMachineArn: this.event.ResourceProperties.stateMachineArn, + name: this.event.RequestId, + input: JSON.stringify(this.event) + }; + await this.startExecution(req); + return; + } else { + const response = await this.processEvent(this.event.ResourceProperties); + return response; + } + } catch (e) { + console.log(e); + throw e; + } finally { + clearTimeout(this.timeout); + } + } + async handleIsComplete() { + try { + const result = await this.processEvent(this.event.ResourceProperties); + return result; + } catch (e) { + console.log(e); + return; + } finally { + clearTimeout(this.timeout); + } + } + async startExecution(req) { + try { + const sfn = new AWS.StepFunctions(); + await sfn.startExecution(req).promise(); + } finally { + clearTimeout(this.timeout); + } + } + respond(response) { + if (this.timedOut) { + return; + } + const cfResponse = { + Status: response.status, + Reason: response.reason, + PhysicalResourceId: this.physicalResourceId, + StackId: this.event.StackId, + RequestId: this.event.RequestId, + LogicalResourceId: this.event.LogicalResourceId, + NoEcho: false, + Data: response.data + }; + const responseBody = JSON.stringify(cfResponse); + console.log("Responding to CloudFormation", responseBody); + const parsedUrl = url.parse(this.event.ResponseURL); + const requestOptions = { + hostname: parsedUrl.hostname, + path: parsedUrl.path, + method: "PUT", + headers: { "content-type": "", "content-length": responseBody.length } + }; + return new Promise((resolve, reject) => { + try { + const request2 = https.request(requestOptions, resolve); + request2.on("error", reject); + request2.write(responseBody); + request2.end(); + } catch (e) { + reject(e); + } finally { + clearTimeout(this.timeout); + } + }); + } +}; +function extractPhysicalResourceId(event) { + switch (event.RequestType) { + case "Create": + return event.LogicalResourceId; + case "Update": + case "Delete": + return event.PhysicalResourceId; + } +} + +// lib/assertions/providers/lambda-handler/assertion.ts +var AssertionHandler = class extends CustomResourceHandler { + async processEvent(request2) { + let actual = decodeCall(request2.actual); + const expected = decodeCall(request2.expected); + let result; + const matcher = new MatchCreator(expected).getMatcher(); + console.log(`Testing equality between ${JSON.stringify(request2.actual)} and ${JSON.stringify(request2.expected)}`); + const matchResult = matcher.test(actual); + matchResult.finished(); + if (matchResult.hasFailed()) { + result = { + failed: true, + assertion: JSON.stringify({ + status: "fail", + message: matchResult.renderMismatch() + }) + }; + if (request2.failDeployment) { + throw new Error(result.assertion); + } + } else { + result = { + assertion: JSON.stringify({ + status: "success" + }) + }; + } + return result; + } +}; +var MatchCreator = class { + constructor(obj) { + this.parsedObj = { + matcher: obj + }; + } + getMatcher() { + try { + const final = JSON.parse(JSON.stringify(this.parsedObj), function(_k, v) { + const nested = Object.keys(v)[0]; + switch (nested) { + case "$ArrayWith": + return Match.arrayWith(v[nested]); + case "$ObjectLike": + return Match.objectLike(v[nested]); + case "$StringLike": + return Match.stringLikeRegexp(v[nested]); + case "$SerializedJson": + return Match.serializedJson(v[nested]); + default: + return v; + } + }); + if (Matcher.isMatcher(final.matcher)) { + return final.matcher; + } + return Match.exact(final.matcher); + } catch { + return Match.exact(this.parsedObj.matcher); + } + } +}; +function decodeCall(call) { + if (!call) { + return void 0; + } + try { + const parsed = JSON.parse(call); + return parsed; + } catch (e) { + return call; + } +} + +// lib/assertions/providers/lambda-handler/utils.ts +function decode(object) { + return JSON.parse(JSON.stringify(object), (_k, v) => { + switch (v) { + case "TRUE:BOOLEAN": + return true; + case "FALSE:BOOLEAN": + return false; + default: + return v; + } + }); +} + +// lib/assertions/providers/lambda-handler/sdk.ts +function flatten(object) { + return Object.assign( + {}, + ...function _flatten(child, path = []) { + return [].concat(...Object.keys(child).map((key) => { + let childKey = Buffer.isBuffer(child[key]) ? child[key].toString("utf8") : child[key]; + if (typeof childKey === "string") { + childKey = isJsonString(childKey); + } + return typeof childKey === "object" && childKey !== null ? _flatten(childKey, path.concat([key])) : { [path.concat([key]).join(".")]: childKey }; + })); + }(object) + ); +} +var AwsApiCallHandler = class extends CustomResourceHandler { + async processEvent(request2) { + const AWS2 = require("aws-sdk"); + console.log(`AWS SDK VERSION: ${AWS2.VERSION}`); + if (!Object.prototype.hasOwnProperty.call(AWS2, request2.service)) { + throw Error(`Service ${request2.service} does not exist in AWS SDK version ${AWS2.VERSION}.`); + } + const service = new AWS2[request2.service](); + const response = await service[request2.api](request2.parameters && decode(request2.parameters)).promise(); + console.log(`SDK response received ${JSON.stringify(response)}`); + delete response.ResponseMetadata; + const respond = { + apiCallResponse: response + }; + const flatData = { + ...flatten(respond) + }; + let resp = respond; + if (request2.outputPaths) { + resp = filterKeys(flatData, request2.outputPaths); + } else if (request2.flattenResponse === "true") { + resp = flatData; + } + console.log(`Returning result ${JSON.stringify(resp)}`); + return resp; + } +}; +function filterKeys(object, searchStrings) { + return Object.entries(object).reduce((filteredObject, [key, value]) => { + for (const searchString of searchStrings) { + if (key.startsWith(`apiCallResponse.${searchString}`)) { + filteredObject[key] = value; + } + } + return filteredObject; + }, {}); +} +function isJsonString(value) { + try { + return JSON.parse(value); + } catch { + return value; + } +} + +// lib/assertions/providers/lambda-handler/types.ts +var ASSERT_RESOURCE_TYPE = "Custom::DeployAssert@AssertEquals"; +var SDK_RESOURCE_TYPE_PREFIX = "Custom::DeployAssert@SdkCall"; + +// lib/assertions/providers/lambda-handler/index.ts +async function handler(event, context) { + console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`); + const provider = createResourceHandler(event, context); + try { + if (event.RequestType === "Delete") { + await provider.respond({ + status: "SUCCESS", + reason: "OK" + }); + return; + } + const result = await provider.handle(); + if ("stateMachineArn" in event.ResourceProperties) { + console.info('Found "stateMachineArn", waiter statemachine started'); + return; + } else if ("expected" in event.ResourceProperties) { + console.info('Found "expected", testing assertions'); + const actualPath = event.ResourceProperties.actualPath; + const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse; + const assertion = new AssertionHandler({ + ...event, + ResourceProperties: { + ServiceToken: event.ServiceToken, + actual, + expected: event.ResourceProperties.expected + } + }, context); + try { + const assertionResult = await assertion.handle(); + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: { + ...assertionResult, + ...result + } + }); + return; + } catch (e) { + await provider.respond({ + status: "FAILED", + reason: e.message ?? "Internal Error" + }); + return; + } + } + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: result + }); + } catch (e) { + await provider.respond({ + status: "FAILED", + reason: e.message ?? "Internal Error" + }); + return; + } + return; +} +async function onTimeout(timeoutEvent) { + const isCompleteRequest = JSON.parse(JSON.parse(timeoutEvent.Cause).errorMessage); + const provider = createResourceHandler(isCompleteRequest, standardContext); + await provider.respond({ + status: "FAILED", + reason: "Operation timed out: " + JSON.stringify(isCompleteRequest) + }); +} +async function isComplete(event, context) { + console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`); + const provider = createResourceHandler(event, context); + try { + const result = await provider.handleIsComplete(); + const actualPath = event.ResourceProperties.actualPath; + if (result) { + const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse; + if ("expected" in event.ResourceProperties) { + const assertion = new AssertionHandler({ + ...event, + ResourceProperties: { + ServiceToken: event.ServiceToken, + actual, + expected: event.ResourceProperties.expected + } + }, context); + const assertionResult = await assertion.handleIsComplete(); + if (!(assertionResult == null ? void 0 : assertionResult.failed)) { + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: { + ...assertionResult, + ...result + } + }); + return; + } else { + console.log(`Assertion Failed: ${JSON.stringify(assertionResult)}`); + throw new Error(JSON.stringify(event)); + } + } + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: result + }); + } else { + console.log("No result"); + throw new Error(JSON.stringify(event)); + } + return; + } catch (e) { + console.log(e); + throw new Error(JSON.stringify(event)); + } +} +function createResourceHandler(event, context) { + if (event.ResourceType.startsWith(SDK_RESOURCE_TYPE_PREFIX)) { + return new AwsApiCallHandler(event, context); + } else if (event.ResourceType.startsWith(ASSERT_RESOURCE_TYPE)) { + return new AssertionHandler(event, context); + } else { + throw new Error(`Unsupported resource type "${event.ResourceType}`); + } +} +var standardContext = { + getRemainingTimeInMillis: () => 9e4 +}; +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + handler, + isComplete, + onTimeout +}); diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a/index.js b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a/index.js new file mode 100644 index 0000000000000..db0dbed85dfd5 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a/index.js @@ -0,0 +1,24 @@ +exports.handler = async function(event) { + console.log(event); + + let myHeaders = new Headers(); + myHeaders.append("x-api-key", event.apiKey); + myHeaders.append("Content-Type", "application/json"); + + const query = JSON.stringify({ + query: "mutation MyMutation {\n addTest(name: \"123\") {\n id\n name\n }\n}", + variables: {} + }); + + const requestOptions = { + method: 'POST', + headers: myHeaders, + body: query, + redirect: 'follow' + }; + + const response = await fetch(event.hostname, requestOptions) + .then(response => response.json()) + + return response; +} diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.d.ts b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.d.ts new file mode 100644 index 0000000000000..9bbf5854684b6 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.d.ts @@ -0,0 +1 @@ +export declare function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context): Promise; diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.js b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.js new file mode 100644 index 0000000000000..d8d501f248a23 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.js @@ -0,0 +1,209 @@ +"use strict"; +/* eslint-disable no-console */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.handler = void 0; +// eslint-disable-next-line import/no-extraneous-dependencies +const AWS = require("aws-sdk"); +/** + * Creates a log group and doesn't throw if it exists. + * + * @param logGroupName the name of the log group to create. + * @param region to create the log group in + * @param options CloudWatch API SDK options. + */ +async function createLogGroupSafe(logGroupName, region, options) { + // If we set the log retention for a lambda, then due to the async nature of + // Lambda logging there could be a race condition when the same log group is + // already being created by the lambda execution. This can sometime result in + // an error "OperationAbortedException: A conflicting operation is currently + // in progress...Please try again." + // To avoid an error, we do as requested and try again. + let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries; + const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base; + do { + try { + const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options }); + await cloudwatchlogs.createLogGroup({ logGroupName }).promise(); + return; + } + catch (error) { + if (error.code === 'ResourceAlreadyExistsException') { + // The log group is already created by the lambda execution + return; + } + if (error.code === 'OperationAbortedException') { + if (retryCount > 0) { + retryCount--; + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } + else { + // The log group is still being created by another execution but we are out of retries + throw new Error('Out of attempts to create a logGroup'); + } + } + throw error; + } + } while (true); // exit happens on retry count check +} +//delete a log group +async function deleteLogGroup(logGroupName, region, options) { + let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries; + const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base; + do { + try { + const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options }); + await cloudwatchlogs.deleteLogGroup({ logGroupName }).promise(); + return; + } + catch (error) { + if (error.code === 'ResourceNotFoundException') { + // The log group doesn't exist + return; + } + if (error.code === 'OperationAbortedException') { + if (retryCount > 0) { + retryCount--; + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } + else { + // The log group is still being deleted by another execution but we are out of retries + throw new Error('Out of attempts to delete a logGroup'); + } + } + throw error; + } + } while (true); // exit happens on retry count check +} +/** + * Puts or deletes a retention policy on a log group. + * + * @param logGroupName the name of the log group to create + * @param region the region of the log group + * @param options CloudWatch API SDK options. + * @param retentionInDays the number of days to retain the log events in the specified log group. + */ +async function setRetentionPolicy(logGroupName, region, options, retentionInDays) { + // The same as in createLogGroupSafe(), here we could end up with the race + // condition where a log group is either already being created or its retention + // policy is being updated. This would result in an OperationAbortedException, + // which we will try to catch and retry the command a number of times before failing + let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries; + const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base; + do { + try { + const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options }); + if (!retentionInDays) { + await cloudwatchlogs.deleteRetentionPolicy({ logGroupName }).promise(); + } + else { + await cloudwatchlogs.putRetentionPolicy({ logGroupName, retentionInDays }).promise(); + } + return; + } + catch (error) { + if (error.code === 'OperationAbortedException') { + if (retryCount > 0) { + retryCount--; + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } + else { + // The log group is still being created by another execution but we are out of retries + throw new Error('Out of attempts to create a logGroup'); + } + } + throw error; + } + } while (true); // exit happens on retry count check +} +async function handler(event, context) { + try { + console.log(JSON.stringify({ ...event, ResponseURL: '...' })); + // The target log group + const logGroupName = event.ResourceProperties.LogGroupName; + // The region of the target log group + const logGroupRegion = event.ResourceProperties.LogGroupRegion; + // Parse to AWS SDK retry options + const retryOptions = parseRetryOptions(event.ResourceProperties.SdkRetry); + if (event.RequestType === 'Create' || event.RequestType === 'Update') { + // Act on the target log group + await createLogGroupSafe(logGroupName, logGroupRegion, retryOptions); + await setRetentionPolicy(logGroupName, logGroupRegion, retryOptions, parseInt(event.ResourceProperties.RetentionInDays, 10)); + if (event.RequestType === 'Create') { + // Set a retention policy of 1 day on the logs of this very function. + // Due to the async nature of the log group creation, the log group for this function might + // still be not created yet at this point. Therefore we attempt to create it. + // In case it is being created, createLogGroupSafe will handle the conflict. + const region = process.env.AWS_REGION; + await createLogGroupSafe(`/aws/lambda/${context.functionName}`, region, retryOptions); + // If createLogGroupSafe fails, the log group is not created even after multiple attempts. + // In this case we have nothing to set the retention policy on but an exception will skip + // the next line. + await setRetentionPolicy(`/aws/lambda/${context.functionName}`, region, retryOptions, 1); + } + } + //When the requestType is delete, delete the log group if the removal policy is delete + if (event.RequestType === 'Delete' && event.ResourceProperties.RemovalPolicy === 'destroy') { + await deleteLogGroup(logGroupName, logGroupRegion, retryOptions); + //else retain the log group + } + await respond('SUCCESS', 'OK', logGroupName); + } + catch (e) { + console.log(e); + await respond('FAILED', e.message, event.ResourceProperties.LogGroupName); + } + function respond(responseStatus, reason, physicalResourceId) { + const responseBody = JSON.stringify({ + Status: responseStatus, + Reason: reason, + PhysicalResourceId: physicalResourceId, + StackId: event.StackId, + RequestId: event.RequestId, + LogicalResourceId: event.LogicalResourceId, + Data: { + // Add log group name as part of the response so that it's available via Fn::GetAtt + LogGroupName: event.ResourceProperties.LogGroupName, + }, + }); + console.log('Responding', responseBody); + // eslint-disable-next-line @typescript-eslint/no-require-imports + const parsedUrl = require('url').parse(event.ResponseURL); + const requestOptions = { + hostname: parsedUrl.hostname, + path: parsedUrl.path, + method: 'PUT', + headers: { 'content-type': '', 'content-length': responseBody.length }, + }; + return new Promise((resolve, reject) => { + try { + // eslint-disable-next-line @typescript-eslint/no-require-imports + const request = require('https').request(requestOptions, resolve); + request.on('error', reject); + request.write(responseBody); + request.end(); + } + catch (e) { + reject(e); + } + }); + } + function parseRetryOptions(rawOptions) { + const retryOptions = {}; + if (rawOptions) { + if (rawOptions.maxRetries) { + retryOptions.maxRetries = parseInt(rawOptions.maxRetries, 10); + } + if (rawOptions.base) { + retryOptions.retryOptions = { + base: parseInt(rawOptions.base, 10), + }; + } + } + return retryOptions; + } +} +exports.handler = handler; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as AWS from 'aws-sdk';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport type { RetryDelayOptions } from 'aws-sdk/lib/config-base';\n\ninterface SdkRetryOptions {\n  maxRetries?: number;\n  retryOptions?: RetryDelayOptions;\n}\n\n/**\n * Creates a log group and doesn't throw if it exists.\n *\n * @param logGroupName the name of the log group to create.\n * @param region to create the log group in\n * @param options CloudWatch API SDK options.\n */\nasync function createLogGroupSafe(logGroupName: string, region?: string, options?: SdkRetryOptions) {\n  // If we set the log retention for a lambda, then due to the async nature of\n  // Lambda logging there could be a race condition when the same log group is\n  // already being created by the lambda execution. This can sometime result in\n  // an error \"OperationAbortedException: A conflicting operation is currently\n  // in progress...Please try again.\"\n  // To avoid an error, we do as requested and try again.\n  let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries;\n  const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base;\n  do {\n    try {\n      const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options });\n      await cloudwatchlogs.createLogGroup({ logGroupName }).promise();\n      return;\n    } catch (error) {\n      if (error.code === 'ResourceAlreadyExistsException') {\n        // The log group is already created by the lambda execution\n        return;\n      }\n      if (error.code === 'OperationAbortedException') {\n        if (retryCount > 0) {\n          retryCount--;\n          await new Promise(resolve => setTimeout(resolve, delay));\n          continue;\n        } else {\n          // The log group is still being created by another execution but we are out of retries\n          throw new Error('Out of attempts to create a logGroup');\n        }\n      }\n      throw error;\n    }\n  } while (true); // exit happens on retry count check\n}\n\n//delete a log group\nasync function deleteLogGroup(logGroupName: string, region?: string, options?: SdkRetryOptions) {\n  let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries;\n  const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base;\n  do {\n    try {\n      const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options });\n      await cloudwatchlogs.deleteLogGroup({ logGroupName }).promise();\n      return;\n    } catch (error) {\n      if (error.code === 'ResourceNotFoundException') {\n        // The log group doesn't exist\n        return;\n      }\n      if (error.code === 'OperationAbortedException') {\n        if (retryCount > 0) {\n          retryCount--;\n          await new Promise(resolve => setTimeout(resolve, delay));\n          continue;\n        } else {\n          // The log group is still being deleted by another execution but we are out of retries\n          throw new Error('Out of attempts to delete a logGroup');\n        }\n      }\n      throw error;\n    }\n  } while (true); // exit happens on retry count check\n}\n\n/**\n * Puts or deletes a retention policy on a log group.\n *\n * @param logGroupName the name of the log group to create\n * @param region the region of the log group\n * @param options CloudWatch API SDK options.\n * @param retentionInDays the number of days to retain the log events in the specified log group.\n */\nasync function setRetentionPolicy(logGroupName: string, region?: string, options?: SdkRetryOptions, retentionInDays?: number) {\n  // The same as in createLogGroupSafe(), here we could end up with the race\n  // condition where a log group is either already being created or its retention\n  // policy is being updated. This would result in an OperationAbortedException,\n  // which we will try to catch and retry the command a number of times before failing\n  let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries;\n  const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base;\n  do {\n    try {\n      const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options });\n      if (!retentionInDays) {\n        await cloudwatchlogs.deleteRetentionPolicy({ logGroupName }).promise();\n      } else {\n        await cloudwatchlogs.putRetentionPolicy({ logGroupName, retentionInDays }).promise();\n      }\n      return;\n\n    } catch (error) {\n      if (error.code === 'OperationAbortedException') {\n        if (retryCount > 0) {\n          retryCount--;\n          await new Promise(resolve => setTimeout(resolve, delay));\n          continue;\n        } else {\n          // The log group is still being created by another execution but we are out of retries\n          throw new Error('Out of attempts to create a logGroup');\n        }\n      }\n      throw error;\n    }\n  } while (true); // exit happens on retry count check\n}\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  try {\n    console.log(JSON.stringify({ ...event, ResponseURL: '...' }));\n\n    // The target log group\n    const logGroupName = event.ResourceProperties.LogGroupName;\n\n    // The region of the target log group\n    const logGroupRegion = event.ResourceProperties.LogGroupRegion;\n\n    // Parse to AWS SDK retry options\n    const retryOptions = parseRetryOptions(event.ResourceProperties.SdkRetry);\n\n    if (event.RequestType === 'Create' || event.RequestType === 'Update') {\n      // Act on the target log group\n      await createLogGroupSafe(logGroupName, logGroupRegion, retryOptions);\n      await setRetentionPolicy(logGroupName, logGroupRegion, retryOptions, parseInt(event.ResourceProperties.RetentionInDays, 10));\n\n      if (event.RequestType === 'Create') {\n        // Set a retention policy of 1 day on the logs of this very function.\n        // Due to the async nature of the log group creation, the log group for this function might\n        // still be not created yet at this point. Therefore we attempt to create it.\n        // In case it is being created, createLogGroupSafe will handle the conflict.\n        const region = process.env.AWS_REGION;\n        await createLogGroupSafe(`/aws/lambda/${context.functionName}`, region, retryOptions);\n        // If createLogGroupSafe fails, the log group is not created even after multiple attempts.\n        // In this case we have nothing to set the retention policy on but an exception will skip\n        // the next line.\n        await setRetentionPolicy(`/aws/lambda/${context.functionName}`, region, retryOptions, 1);\n      }\n    }\n\n    //When the requestType is delete, delete the log group if the removal policy is delete\n    if (event.RequestType === 'Delete' && event.ResourceProperties.RemovalPolicy === 'destroy') {\n      await deleteLogGroup(logGroupName, logGroupRegion, retryOptions);\n      //else retain the log group\n    }\n\n    await respond('SUCCESS', 'OK', logGroupName);\n  } catch (e) {\n    console.log(e);\n\n    await respond('FAILED', e.message, event.ResourceProperties.LogGroupName);\n  }\n\n  function respond(responseStatus: string, reason: string, physicalResourceId: string) {\n    const responseBody = JSON.stringify({\n      Status: responseStatus,\n      Reason: reason,\n      PhysicalResourceId: physicalResourceId,\n      StackId: event.StackId,\n      RequestId: event.RequestId,\n      LogicalResourceId: event.LogicalResourceId,\n      Data: {\n        // Add log group name as part of the response so that it's available via Fn::GetAtt\n        LogGroupName: event.ResourceProperties.LogGroupName,\n      },\n    });\n\n    console.log('Responding', responseBody);\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const parsedUrl = require('url').parse(event.ResponseURL);\n    const requestOptions = {\n      hostname: parsedUrl.hostname,\n      path: parsedUrl.path,\n      method: 'PUT',\n      headers: { 'content-type': '', 'content-length': responseBody.length },\n    };\n\n    return new Promise((resolve, reject) => {\n      try {\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const request = require('https').request(requestOptions, resolve);\n        request.on('error', reject);\n        request.write(responseBody);\n        request.end();\n      } catch (e) {\n        reject(e);\n      }\n    });\n  }\n\n  function parseRetryOptions(rawOptions: any): SdkRetryOptions {\n    const retryOptions: SdkRetryOptions = {};\n    if (rawOptions) {\n      if (rawOptions.maxRetries) {\n        retryOptions.maxRetries = parseInt(rawOptions.maxRetries, 10);\n      }\n      if (rawOptions.base) {\n        retryOptions.retryOptions = {\n          base: parseInt(rawOptions.base, 10),\n        };\n      }\n    }\n    return retryOptions;\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.ts b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.ts new file mode 100644 index 0000000000000..1bb38a9f3d774 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/asset.d01c24641c7d8cb6488393ffceaefff282370a9a522bf9d77b21da73fa257347/index.ts @@ -0,0 +1,221 @@ +/* eslint-disable no-console */ + +// eslint-disable-next-line import/no-extraneous-dependencies +import * as AWS from 'aws-sdk'; +// eslint-disable-next-line import/no-extraneous-dependencies +import type { RetryDelayOptions } from 'aws-sdk/lib/config-base'; + +interface SdkRetryOptions { + maxRetries?: number; + retryOptions?: RetryDelayOptions; +} + +/** + * Creates a log group and doesn't throw if it exists. + * + * @param logGroupName the name of the log group to create. + * @param region to create the log group in + * @param options CloudWatch API SDK options. + */ +async function createLogGroupSafe(logGroupName: string, region?: string, options?: SdkRetryOptions) { + // If we set the log retention for a lambda, then due to the async nature of + // Lambda logging there could be a race condition when the same log group is + // already being created by the lambda execution. This can sometime result in + // an error "OperationAbortedException: A conflicting operation is currently + // in progress...Please try again." + // To avoid an error, we do as requested and try again. + let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries; + const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base; + do { + try { + const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options }); + await cloudwatchlogs.createLogGroup({ logGroupName }).promise(); + return; + } catch (error) { + if (error.code === 'ResourceAlreadyExistsException') { + // The log group is already created by the lambda execution + return; + } + if (error.code === 'OperationAbortedException') { + if (retryCount > 0) { + retryCount--; + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } else { + // The log group is still being created by another execution but we are out of retries + throw new Error('Out of attempts to create a logGroup'); + } + } + throw error; + } + } while (true); // exit happens on retry count check +} + +//delete a log group +async function deleteLogGroup(logGroupName: string, region?: string, options?: SdkRetryOptions) { + let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries; + const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base; + do { + try { + const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options }); + await cloudwatchlogs.deleteLogGroup({ logGroupName }).promise(); + return; + } catch (error) { + if (error.code === 'ResourceNotFoundException') { + // The log group doesn't exist + return; + } + if (error.code === 'OperationAbortedException') { + if (retryCount > 0) { + retryCount--; + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } else { + // The log group is still being deleted by another execution but we are out of retries + throw new Error('Out of attempts to delete a logGroup'); + } + } + throw error; + } + } while (true); // exit happens on retry count check +} + +/** + * Puts or deletes a retention policy on a log group. + * + * @param logGroupName the name of the log group to create + * @param region the region of the log group + * @param options CloudWatch API SDK options. + * @param retentionInDays the number of days to retain the log events in the specified log group. + */ +async function setRetentionPolicy(logGroupName: string, region?: string, options?: SdkRetryOptions, retentionInDays?: number) { + // The same as in createLogGroupSafe(), here we could end up with the race + // condition where a log group is either already being created or its retention + // policy is being updated. This would result in an OperationAbortedException, + // which we will try to catch and retry the command a number of times before failing + let retryCount = options?.maxRetries == undefined ? 10 : options.maxRetries; + const delay = options?.retryOptions?.base == undefined ? 10 : options.retryOptions.base; + do { + try { + const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28', region, ...options }); + if (!retentionInDays) { + await cloudwatchlogs.deleteRetentionPolicy({ logGroupName }).promise(); + } else { + await cloudwatchlogs.putRetentionPolicy({ logGroupName, retentionInDays }).promise(); + } + return; + + } catch (error) { + if (error.code === 'OperationAbortedException') { + if (retryCount > 0) { + retryCount--; + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } else { + // The log group is still being created by another execution but we are out of retries + throw new Error('Out of attempts to create a logGroup'); + } + } + throw error; + } + } while (true); // exit happens on retry count check +} + +export async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) { + try { + console.log(JSON.stringify({ ...event, ResponseURL: '...' })); + + // The target log group + const logGroupName = event.ResourceProperties.LogGroupName; + + // The region of the target log group + const logGroupRegion = event.ResourceProperties.LogGroupRegion; + + // Parse to AWS SDK retry options + const retryOptions = parseRetryOptions(event.ResourceProperties.SdkRetry); + + if (event.RequestType === 'Create' || event.RequestType === 'Update') { + // Act on the target log group + await createLogGroupSafe(logGroupName, logGroupRegion, retryOptions); + await setRetentionPolicy(logGroupName, logGroupRegion, retryOptions, parseInt(event.ResourceProperties.RetentionInDays, 10)); + + if (event.RequestType === 'Create') { + // Set a retention policy of 1 day on the logs of this very function. + // Due to the async nature of the log group creation, the log group for this function might + // still be not created yet at this point. Therefore we attempt to create it. + // In case it is being created, createLogGroupSafe will handle the conflict. + const region = process.env.AWS_REGION; + await createLogGroupSafe(`/aws/lambda/${context.functionName}`, region, retryOptions); + // If createLogGroupSafe fails, the log group is not created even after multiple attempts. + // In this case we have nothing to set the retention policy on but an exception will skip + // the next line. + await setRetentionPolicy(`/aws/lambda/${context.functionName}`, region, retryOptions, 1); + } + } + + //When the requestType is delete, delete the log group if the removal policy is delete + if (event.RequestType === 'Delete' && event.ResourceProperties.RemovalPolicy === 'destroy') { + await deleteLogGroup(logGroupName, logGroupRegion, retryOptions); + //else retain the log group + } + + await respond('SUCCESS', 'OK', logGroupName); + } catch (e) { + console.log(e); + + await respond('FAILED', e.message, event.ResourceProperties.LogGroupName); + } + + function respond(responseStatus: string, reason: string, physicalResourceId: string) { + const responseBody = JSON.stringify({ + Status: responseStatus, + Reason: reason, + PhysicalResourceId: physicalResourceId, + StackId: event.StackId, + RequestId: event.RequestId, + LogicalResourceId: event.LogicalResourceId, + Data: { + // Add log group name as part of the response so that it's available via Fn::GetAtt + LogGroupName: event.ResourceProperties.LogGroupName, + }, + }); + + console.log('Responding', responseBody); + + // eslint-disable-next-line @typescript-eslint/no-require-imports + const parsedUrl = require('url').parse(event.ResponseURL); + const requestOptions = { + hostname: parsedUrl.hostname, + path: parsedUrl.path, + method: 'PUT', + headers: { 'content-type': '', 'content-length': responseBody.length }, + }; + + return new Promise((resolve, reject) => { + try { + // eslint-disable-next-line @typescript-eslint/no-require-imports + const request = require('https').request(requestOptions, resolve); + request.on('error', reject); + request.write(responseBody); + request.end(); + } catch (e) { + reject(e); + } + }); + } + + function parseRetryOptions(rawOptions: any): SdkRetryOptions { + const retryOptions: SdkRetryOptions = {}; + if (rawOptions) { + if (rawOptions.maxRetries) { + retryOptions.maxRetries = parseInt(rawOptions.maxRetries, 10); + } + if (rawOptions.base) { + retryOptions.retryOptions = { + base: parseInt(rawOptions.base, 10), + }; + } + } + return retryOptions; + } +} diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/cdk.out b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/cdk.out new file mode 100644 index 0000000000000..145739f539580 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/cdk.out @@ -0,0 +1 @@ +{"version":"22.0.0"} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/integ.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/integ.json new file mode 100644 index 0000000000000..39476a823eb97 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/integ.json @@ -0,0 +1,12 @@ +{ + "version": "22.0.0", + "testCases": { + "JsResolverIntegTest/DefaultTest": { + "stacks": [ + "AppSyncJsResolverTestStack" + ], + "assertionStack": "JsResolverIntegTest/DefaultTest/DeployAssert", + "assertionStackName": "JsResolverIntegTestDefaultTestDeployAssert57AD8D20" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/manifest.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/manifest.json new file mode 100644 index 0000000000000..b7856825b96ef --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/manifest.json @@ -0,0 +1,268 @@ +{ + "version": "22.0.0", + "artifacts": { + "AppSyncJsResolverTestStack.assets": { + "type": "cdk:asset-manifest", + "properties": { + "file": "AppSyncJsResolverTestStack.assets.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "AppSyncJsResolverTestStack": { + "type": "aws:cloudformation:stack", + "environment": "aws://unknown-account/unknown-region", + "properties": { + "templateFile": "AppSyncJsResolverTestStack.template.json", + "validateOnSynth": false, + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-${AWS::Region}", + "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-${AWS::Region}", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/e8854d9a08f981fd59e6f71b86e4266fb80f578b9f7edd5cce794f4f302404e7.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", + "additionalDependencies": [ + "AppSyncJsResolverTestStack.assets" + ], + "lookupRole": { + "arn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-lookup-role-${AWS::AccountId}-${AWS::Region}", + "requiresBootstrapStackVersion": 8, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "dependencies": [ + "AppSyncJsResolverTestStack.assets" + ], + "metadata": { + "/AppSyncJsResolverTestStack/JsResolverApi/ApiLogsRole/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiApiLogsRoleAA94FCF2" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApi612CD442" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/Schema": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiSchema1CF261C1" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/DefaultApiKey": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiDefaultApiKeyBD458F31" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/LogRetention/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiLogRetention66DE3830" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiDynamoDataSourceServiceRole6406F7E8" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole/DefaultPolicy/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiDynamoDataSourceServiceRoleDefaultPolicy44BA5FB6" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiDynamoDataSource58CF75DE" + } + ], + "/AppSyncJsResolverTestStack/JsResolverApi/AddTestFunction/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "JsResolverApiAddTestFunction76B4557F" + } + ], + "/AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRole9741ECFB" + } + ], + "/AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/DefaultPolicy/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRoleDefaultPolicyADDA7DEB" + } + ], + "/AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aFD4BFC8A" + } + ], + "/AppSyncJsResolverTestStack/DynamoTable/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "DynamoTableB2B22E15" + } + ], + "/AppSyncJsResolverTestStack/AddTestResolver/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "AddTestResolver8AF95A30" + } + ], + "/AppSyncJsResolverTestStack/InvokeApi/ServiceRole/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "InvokeApiServiceRoleFB17CD97" + } + ], + "/AppSyncJsResolverTestStack/InvokeApi/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "InvokeApi313C8B49" + } + ], + "/AppSyncJsResolverTestStack/Exports/Output{\"Ref\":\"InvokeApi313C8B49\"}": [ + { + "type": "aws:cdk:logicalId", + "data": "ExportsOutputRefInvokeApi313C8B4949AC2AFC" + } + ], + "/AppSyncJsResolverTestStack/Exports/Output{\"Fn::GetAtt\":[\"JsResolverApi612CD442\",\"GraphQLUrl\"]}": [ + { + "type": "aws:cdk:logicalId", + "data": "ExportsOutputFnGetAttJsResolverApi612CD442GraphQLUrl15495788" + } + ], + "/AppSyncJsResolverTestStack/Exports/Output{\"Fn::GetAtt\":[\"JsResolverApiDefaultApiKeyBD458F31\",\"ApiKey\"]}": [ + { + "type": "aws:cdk:logicalId", + "data": "ExportsOutputFnGetAttJsResolverApiDefaultApiKeyBD458F31ApiKey4D429933" + } + ], + "/AppSyncJsResolverTestStack/Exports/Output{\"Ref\":\"DynamoTableB2B22E15\"}": [ + { + "type": "aws:cdk:logicalId", + "data": "ExportsOutputRefDynamoTableB2B22E1592AFC2EE" + } + ], + "/AppSyncJsResolverTestStack/BootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "BootstrapVersion" + } + ], + "/AppSyncJsResolverTestStack/CheckBootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "CheckBootstrapVersion" + } + ] + }, + "displayName": "AppSyncJsResolverTestStack" + }, + "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets": { + "type": "cdk:asset-manifest", + "properties": { + "file": "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "JsResolverIntegTestDefaultTestDeployAssert57AD8D20": { + "type": "aws:cloudformation:stack", + "environment": "aws://unknown-account/unknown-region", + "properties": { + "templateFile": "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.template.json", + "validateOnSynth": false, + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-${AWS::Region}", + "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-${AWS::Region}", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/c9a130d7c2610c9af13d14efb06865c2d07c3a490c0a67ad7fd335b68dabe3e3.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", + "additionalDependencies": [ + "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets" + ], + "lookupRole": { + "arn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-lookup-role-${AWS::AccountId}-${AWS::Region}", + "requiresBootstrapStackVersion": 8, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "dependencies": [ + "AppSyncJsResolverTestStack", + "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets" + ], + "metadata": { + "/JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/Default/Default": [ + { + "type": "aws:cdk:logicalId", + "data": "LambdaInvokeb55e453397dded0a19101717f7183064" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/Invoke": [ + { + "type": "aws:cdk:logicalId", + "data": "LambdaInvokeb55e453397dded0a19101717f7183064InvokeF9C77644" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/AssertionResults": [ + { + "type": "aws:cdk:logicalId", + "data": "AssertionResultsLambdaInvokeb55e453397dded0a19101717f7183064" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Role": [ + { + "type": "aws:cdk:logicalId", + "data": "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Handler": [ + { + "type": "aws:cdk:logicalId", + "data": "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/Default/Default": [ + { + "type": "aws:cdk:logicalId", + "data": "AwsApiCallDynamoDBgetItem" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/AssertionResults": [ + { + "type": "aws:cdk:logicalId", + "data": "AssertionResultsAwsApiCallDynamoDBgetItem" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/BootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "BootstrapVersion" + } + ], + "/JsResolverIntegTest/DefaultTest/DeployAssert/CheckBootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "CheckBootstrapVersion" + } + ] + }, + "displayName": "JsResolverIntegTest/DefaultTest/DeployAssert" + }, + "Tree": { + "type": "cdk:tree", + "properties": { + "file": "tree.json" + } + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/tree.json b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/tree.json new file mode 100644 index 0000000000000..be026b03e49cd --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/tree.json @@ -0,0 +1,1049 @@ +{ + "version": "tree-0.1", + "tree": { + "id": "App", + "path": "", + "children": { + "AppSyncJsResolverTestStack": { + "id": "AppSyncJsResolverTestStack", + "path": "AppSyncJsResolverTestStack", + "children": { + "JsResolverApi": { + "id": "JsResolverApi", + "path": "AppSyncJsResolverTestStack/JsResolverApi", + "children": { + "ApiLogsRole": { + "id": "ApiLogsRole", + "path": "AppSyncJsResolverTestStack/JsResolverApi/ApiLogsRole", + "children": { + "ImportApiLogsRole": { + "id": "ImportApiLogsRole", + "path": "AppSyncJsResolverTestStack/JsResolverApi/ApiLogsRole/ImportApiLogsRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/ApiLogsRole/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Role", + "aws:cdk:cloudformation:props": { + "assumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "appsync.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "managedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSAppSyncPushToCloudWatchLogs" + ] + ] + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnRole", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Role", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::AppSync::GraphQLApi", + "aws:cdk:cloudformation:props": { + "authenticationType": "API_KEY", + "name": "JsResolverApi", + "logConfig": { + "cloudWatchLogsRoleArn": { + "Fn::GetAtt": [ + "JsResolverApiApiLogsRoleAA94FCF2", + "Arn" + ] + }, + "fieldLogLevel": "NONE" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.CfnGraphQLApi", + "version": "0.0.0" + } + }, + "Schema": { + "id": "Schema", + "path": "AppSyncJsResolverTestStack/JsResolverApi/Schema", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::AppSync::GraphQLSchema", + "aws:cdk:cloudformation:props": { + "apiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "definition": "type Test {\n id: String!\n name: String!\n}\ntype Query {\n getTests: [Test]!\n}\ntype Mutation {\n addTest(name: String!): Test\n}\n" + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.CfnGraphQLSchema", + "version": "0.0.0" + } + }, + "DefaultApiKey": { + "id": "DefaultApiKey", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DefaultApiKey", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::AppSync::ApiKey", + "aws:cdk:cloudformation:props": { + "apiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.CfnApiKey", + "version": "0.0.0" + } + }, + "LogGroup": { + "id": "LogGroup", + "path": "AppSyncJsResolverTestStack/JsResolverApi/LogGroup", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "LogRetention": { + "id": "LogRetention", + "path": "AppSyncJsResolverTestStack/JsResolverApi/LogRetention", + "children": { + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/LogRetention/Resource", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-logs.LogRetention", + "version": "0.0.0" + } + }, + "DynamoDataSource": { + "id": "DynamoDataSource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource", + "children": { + "ServiceRole": { + "id": "ServiceRole", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole", + "children": { + "ImportServiceRole": { + "id": "ImportServiceRole", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole/ImportServiceRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Role", + "aws:cdk:cloudformation:props": { + "assumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "appsync.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnRole", + "version": "0.0.0" + } + }, + "DefaultPolicy": { + "id": "DefaultPolicy", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole/DefaultPolicy", + "children": { + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/ServiceRole/DefaultPolicy/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Policy", + "aws:cdk:cloudformation:props": { + "policyDocument": { + "Statement": [ + { + "Action": [ + "dynamodb:BatchGetItem", + "dynamodb:BatchWriteItem", + "dynamodb:ConditionCheckItem", + "dynamodb:DeleteItem", + "dynamodb:DescribeTable", + "dynamodb:GetItem", + "dynamodb:GetRecords", + "dynamodb:GetShardIterator", + "dynamodb:PutItem", + "dynamodb:Query", + "dynamodb:Scan", + "dynamodb:UpdateItem" + ], + "Effect": "Allow", + "Resource": [ + { + "Fn::GetAtt": [ + "DynamoTableB2B22E15", + "Arn" + ] + }, + { + "Ref": "AWS::NoValue" + } + ] + } + ], + "Version": "2012-10-17" + }, + "policyName": "JsResolverApiDynamoDataSourceServiceRoleDefaultPolicy44BA5FB6", + "roles": [ + { + "Ref": "JsResolverApiDynamoDataSourceServiceRole6406F7E8" + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnPolicy", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Policy", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Role", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/DynamoDataSource/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::AppSync::DataSource", + "aws:cdk:cloudformation:props": { + "apiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "name": "DynamoDataSource", + "type": "AMAZON_DYNAMODB", + "dynamoDbConfig": { + "tableName": { + "Ref": "DynamoTableB2B22E15" + }, + "awsRegion": { + "Ref": "AWS::Region" + } + }, + "serviceRoleArn": { + "Fn::GetAtt": [ + "JsResolverApiDynamoDataSourceServiceRole6406F7E8", + "Arn" + ] + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.CfnDataSource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.DynamoDbDataSource", + "version": "0.0.0" + } + }, + "AddTestFunction": { + "id": "AddTestFunction", + "path": "AppSyncJsResolverTestStack/JsResolverApi/AddTestFunction", + "children": { + "Code": { + "id": "Code", + "path": "AppSyncJsResolverTestStack/JsResolverApi/AddTestFunction/Code", + "children": { + "Stage": { + "id": "Stage", + "path": "AppSyncJsResolverTestStack/JsResolverApi/AddTestFunction/Code/Stage", + "constructInfo": { + "fqn": "@aws-cdk/core.AssetStaging", + "version": "0.0.0" + } + }, + "AssetBucket": { + "id": "AssetBucket", + "path": "AppSyncJsResolverTestStack/JsResolverApi/AddTestFunction/Code/AssetBucket", + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.BucketBase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3-assets.Asset", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/JsResolverApi/AddTestFunction/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::AppSync::FunctionConfiguration", + "aws:cdk:cloudformation:props": { + "apiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "dataSourceName": "DynamoDataSource", + "name": "addTestFunc", + "codeS3Location": { + "Fn::Sub": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/64f136fd66d0a20e8574eddfe2e50aa10168344ebac0f3ca03e5ae0b4b7475ec.js" + }, + "functionVersion": "2018-05-29", + "runtime": { + "name": "APPSYNC_JS", + "runtimeVersion": "1.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.CfnFunctionConfiguration", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.AppsyncFunction", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.GraphqlApi", + "version": "0.0.0" + } + }, + "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a": { + "id": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a", + "children": { + "Code": { + "id": "Code", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/Code", + "children": { + "Stage": { + "id": "Stage", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/Code/Stage", + "constructInfo": { + "fqn": "@aws-cdk/core.AssetStaging", + "version": "0.0.0" + } + }, + "AssetBucket": { + "id": "AssetBucket", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/Code/AssetBucket", + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.BucketBase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3-assets.Asset", + "version": "0.0.0" + } + }, + "ServiceRole": { + "id": "ServiceRole", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole", + "children": { + "ImportServiceRole": { + "id": "ImportServiceRole", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/ImportServiceRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Role", + "aws:cdk:cloudformation:props": { + "assumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "managedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + ] + ] + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnRole", + "version": "0.0.0" + } + }, + "DefaultPolicy": { + "id": "DefaultPolicy", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/DefaultPolicy", + "children": { + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/DefaultPolicy/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Policy", + "aws:cdk:cloudformation:props": { + "policyDocument": { + "Statement": [ + { + "Action": [ + "logs:DeleteRetentionPolicy", + "logs:PutRetentionPolicy" + ], + "Effect": "Allow", + "Resource": "*" + } + ], + "Version": "2012-10-17" + }, + "policyName": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRoleDefaultPolicyADDA7DEB", + "roles": [ + { + "Ref": "LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8aServiceRole9741ECFB" + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnPolicy", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Policy", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Role", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/Resource", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + }, + "DynamoTable": { + "id": "DynamoTable", + "path": "AppSyncJsResolverTestStack/DynamoTable", + "children": { + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/DynamoTable/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::DynamoDB::Table", + "aws:cdk:cloudformation:props": { + "keySchema": [ + { + "attributeName": "id", + "keyType": "HASH" + } + ], + "attributeDefinitions": [ + { + "attributeName": "id", + "attributeType": "S" + } + ], + "provisionedThroughput": { + "readCapacityUnits": 5, + "writeCapacityUnits": 5 + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-dynamodb.CfnTable", + "version": "0.0.0" + } + }, + "ScalingRole": { + "id": "ScalingRole", + "path": "AppSyncJsResolverTestStack/DynamoTable/ScalingRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-dynamodb.Table", + "version": "0.0.0" + } + }, + "AddTestResolver": { + "id": "AddTestResolver", + "path": "AppSyncJsResolverTestStack/AddTestResolver", + "children": { + "Code": { + "id": "Code", + "path": "AppSyncJsResolverTestStack/AddTestResolver/Code", + "children": { + "Stage": { + "id": "Stage", + "path": "AppSyncJsResolverTestStack/AddTestResolver/Code/Stage", + "constructInfo": { + "fqn": "@aws-cdk/core.AssetStaging", + "version": "0.0.0" + } + }, + "AssetBucket": { + "id": "AssetBucket", + "path": "AppSyncJsResolverTestStack/AddTestResolver/Code/AssetBucket", + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.BucketBase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3-assets.Asset", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/AddTestResolver/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::AppSync::Resolver", + "aws:cdk:cloudformation:props": { + "apiId": { + "Fn::GetAtt": [ + "JsResolverApi612CD442", + "ApiId" + ] + }, + "fieldName": "addTest", + "typeName": "Mutation", + "codeS3Location": { + "Fn::Sub": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/922ddc9d9563ca9402e283efe80ad2b4e00c8ddf6fbbbc2ae2b9dc6fe7107061.js" + }, + "kind": "PIPELINE", + "pipelineConfig": { + "functions": [ + { + "Fn::GetAtt": [ + "JsResolverApiAddTestFunction76B4557F", + "FunctionId" + ] + } + ] + }, + "runtime": { + "name": "APPSYNC_JS", + "runtimeVersion": "1.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.CfnResolver", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-appsync.Resolver", + "version": "0.0.0" + } + }, + "InvokeApi": { + "id": "InvokeApi", + "path": "AppSyncJsResolverTestStack/InvokeApi", + "children": { + "ServiceRole": { + "id": "ServiceRole", + "path": "AppSyncJsResolverTestStack/InvokeApi/ServiceRole", + "children": { + "ImportServiceRole": { + "id": "ImportServiceRole", + "path": "AppSyncJsResolverTestStack/InvokeApi/ServiceRole/ImportServiceRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/InvokeApi/ServiceRole/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Role", + "aws:cdk:cloudformation:props": { + "assumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "managedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + ] + ] + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnRole", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Role", + "version": "0.0.0" + } + }, + "Code": { + "id": "Code", + "path": "AppSyncJsResolverTestStack/InvokeApi/Code", + "children": { + "Stage": { + "id": "Stage", + "path": "AppSyncJsResolverTestStack/InvokeApi/Code/Stage", + "constructInfo": { + "fqn": "@aws-cdk/core.AssetStaging", + "version": "0.0.0" + } + }, + "AssetBucket": { + "id": "AssetBucket", + "path": "AppSyncJsResolverTestStack/InvokeApi/Code/AssetBucket", + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.BucketBase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3-assets.Asset", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "AppSyncJsResolverTestStack/InvokeApi/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::Lambda::Function", + "aws:cdk:cloudformation:props": { + "code": { + "s3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" + }, + "s3Key": "c8a056b7b029cede879af4833f48bcc456748b2f8456f85ba76393466c08693a.zip" + }, + "role": { + "Fn::GetAtt": [ + "InvokeApiServiceRoleFB17CD97", + "Arn" + ] + }, + "handler": "index.handler", + "runtime": "nodejs18.x" + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-lambda.CfnFunction", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-lambda.Function", + "version": "0.0.0" + } + }, + "Exports": { + "id": "Exports", + "path": "AppSyncJsResolverTestStack/Exports", + "children": { + "Output{\"Ref\":\"InvokeApi313C8B49\"}": { + "id": "Output{\"Ref\":\"InvokeApi313C8B49\"}", + "path": "AppSyncJsResolverTestStack/Exports/Output{\"Ref\":\"InvokeApi313C8B49\"}", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnOutput", + "version": "0.0.0" + } + }, + "Output{\"Fn::GetAtt\":[\"JsResolverApi612CD442\",\"GraphQLUrl\"]}": { + "id": "Output{\"Fn::GetAtt\":[\"JsResolverApi612CD442\",\"GraphQLUrl\"]}", + "path": "AppSyncJsResolverTestStack/Exports/Output{\"Fn::GetAtt\":[\"JsResolverApi612CD442\",\"GraphQLUrl\"]}", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnOutput", + "version": "0.0.0" + } + }, + "Output{\"Fn::GetAtt\":[\"JsResolverApiDefaultApiKeyBD458F31\",\"ApiKey\"]}": { + "id": "Output{\"Fn::GetAtt\":[\"JsResolverApiDefaultApiKeyBD458F31\",\"ApiKey\"]}", + "path": "AppSyncJsResolverTestStack/Exports/Output{\"Fn::GetAtt\":[\"JsResolverApiDefaultApiKeyBD458F31\",\"ApiKey\"]}", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnOutput", + "version": "0.0.0" + } + }, + "Output{\"Ref\":\"DynamoTableB2B22E15\"}": { + "id": "Output{\"Ref\":\"DynamoTableB2B22E15\"}", + "path": "AppSyncJsResolverTestStack/Exports/Output{\"Ref\":\"DynamoTableB2B22E15\"}", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnOutput", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + }, + "BootstrapVersion": { + "id": "BootstrapVersion", + "path": "AppSyncJsResolverTestStack/BootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnParameter", + "version": "0.0.0" + } + }, + "CheckBootstrapVersion": { + "id": "CheckBootstrapVersion", + "path": "AppSyncJsResolverTestStack/CheckBootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnRule", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.Stack", + "version": "0.0.0" + } + }, + "JsResolverIntegTest": { + "id": "JsResolverIntegTest", + "path": "JsResolverIntegTest", + "children": { + "DefaultTest": { + "id": "DefaultTest", + "path": "JsResolverIntegTest/DefaultTest", + "children": { + "Default": { + "id": "Default", + "path": "JsResolverIntegTest/DefaultTest/Default", + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + }, + "DeployAssert": { + "id": "DeployAssert", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert", + "children": { + "LambdaInvokeb55e453397dded0a19101717f7183064": { + "id": "LambdaInvokeb55e453397dded0a19101717f7183064", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064", + "children": { + "SdkProvider": { + "id": "SdkProvider", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/SdkProvider", + "children": { + "AssertionsProvider": { + "id": "AssertionsProvider", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/SdkProvider/AssertionsProvider", + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.AssertionsProvider", + "version": "0.0.0" + } + }, + "Default": { + "id": "Default", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/Default", + "children": { + "Default": { + "id": "Default", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/Default/Default", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.CustomResource", + "version": "0.0.0" + } + }, + "Invoke": { + "id": "Invoke", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/Invoke", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + }, + "AssertionResults": { + "id": "AssertionResults", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/LambdaInvokeb55e453397dded0a19101717f7183064/AssertionResults", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnOutput", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.LambdaInvokeFunction", + "version": "0.0.0" + } + }, + "SingletonFunction1488541a7b23466481b69b4408076b81": { + "id": "SingletonFunction1488541a7b23466481b69b4408076b81", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81", + "children": { + "Staging": { + "id": "Staging", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Staging", + "constructInfo": { + "fqn": "@aws-cdk/core.AssetStaging", + "version": "0.0.0" + } + }, + "Role": { + "id": "Role", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Role", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + }, + "Handler": { + "id": "Handler", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Handler", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + }, + "AwsApiCallDynamoDBgetItem": { + "id": "AwsApiCallDynamoDBgetItem", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem", + "children": { + "SdkProvider": { + "id": "SdkProvider", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/SdkProvider", + "children": { + "AssertionsProvider": { + "id": "AssertionsProvider", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/SdkProvider/AssertionsProvider", + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.AssertionsProvider", + "version": "0.0.0" + } + }, + "Default": { + "id": "Default", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/Default", + "children": { + "Default": { + "id": "Default", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/Default/Default", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.CustomResource", + "version": "0.0.0" + } + }, + "AssertionResults": { + "id": "AssertionResults", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/AwsApiCallDynamoDBgetItem/AssertionResults", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnOutput", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.AwsApiCall", + "version": "0.0.0" + } + }, + "BootstrapVersion": { + "id": "BootstrapVersion", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/BootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnParameter", + "version": "0.0.0" + } + }, + "CheckBootstrapVersion": { + "id": "CheckBootstrapVersion", + "path": "JsResolverIntegTest/DefaultTest/DeployAssert/CheckBootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnRule", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.Stack", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.IntegTestCase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.IntegTest", + "version": "0.0.0" + } + }, + "Tree": { + "id": "Tree", + "path": "Tree", + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.189" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.App", + "version": "0.0.0" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.ts b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.ts new file mode 100644 index 0000000000000..c59bcf53e88b3 --- /dev/null +++ b/packages/@aws-cdk/aws-appsync/test/integ.js-resolver.ts @@ -0,0 +1,113 @@ +import * as path from 'path'; +import * as dynamodb from '@aws-cdk/aws-dynamodb'; +import * as lambda from '@aws-cdk/aws-lambda'; +import * as logs from '@aws-cdk/aws-logs'; +import * as cdk from '@aws-cdk/core'; +import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests'; +import * as appsync from '../lib'; + +const app = new cdk.App(); +const stack = new cdk.Stack(app, 'AppSyncJsResolverTestStack'); + +const logConfig: appsync.LogConfig = { + retention: logs.RetentionDays.ONE_WEEK, +}; + +const api = new appsync.GraphqlApi(stack, 'JsResolverApi', { + name: 'JsResolverApi', + schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'appsync.js-resolver.graphql')), + logConfig, +}); + +const db = new dynamodb.Table(stack, 'DynamoTable', { + partitionKey: { + name: 'id', + type: dynamodb.AttributeType.STRING, + }, + removalPolicy: cdk.RemovalPolicy.DESTROY, +}); + +const dataSource = api.addDynamoDbDataSource('DynamoDataSource', db); + +const addTestFunc = dataSource.createFunction('AddTestFunction', { + name: 'addTestFunc', + runtime: appsync.FunctionRuntime.JS_1_0_0, + code: appsync.Code.fromAsset(path.join( + __dirname, + 'integ-assets', + 'appsync-js-resolver.js', + )), +}); + +new appsync.Resolver(stack, 'AddTestResolver', { + api, + typeName: 'Mutation', + fieldName: 'addTest', + code: appsync.Code.fromAsset(path.join( + __dirname, + 'integ-assets', + 'appsync-js-pipeline.js', + )), + runtime: appsync.FunctionRuntime.JS_1_0_0, + pipelineConfig: [addTestFunc], +}); + +const integ = new IntegTest(app, 'JsResolverIntegTest', { testCases: [stack] }); + +/** + * Handler that calls our api with an `addTest` Mutation + */ +const invoke = new lambda.Function(stack, 'InvokeApi', { + code: lambda.Code.fromAsset(path.join(__dirname, 'integ-assets/js-resolver-assertion')), + handler: 'index.handler', + runtime: lambda.Runtime.NODEJS_18_X, +}); + +const addTestInvoke = integ.assertions.invokeFunction({ + functionName: invoke.functionName, + payload: JSON.stringify({ + hostname: api.graphqlUrl, + apiKey: api.apiKey, + }), +}); + +/** + * Assert result returned on API has a generated ID and the passed name. + */ +addTestInvoke.assertAtPath( + 'Payload.data.addTest.name', + ExpectedResult.stringLikeRegexp('123'), +); + +addTestInvoke.assertAtPath( + 'Payload.data.addTest.id', + ExpectedResult.stringLikeRegexp('.+'), +); + +/** + * Generated ID of the item added in the previous handler + */ +const addTestResultId = addTestInvoke.getAttString('Payload.data.addTest.id'); + +/** + * Try to find the item added in the DynamoDB data source. + */ +const getItemCall = integ.assertions.awsApiCall('DynamoDB', 'getItem', { + TableName: db.tableName, + Key: { + id: { + S: addTestResultId, + }, + }, +}); + +getItemCall.expect(ExpectedResult.objectLike({ + Item: { + name: { + S: '123', + }, + id: { + S: addTestResultId, + }, + }, +}));