feat(appsync): js resolver support

Adds support for resolvers using the APPSYNC_JS runtime. Adds new props
for specifying `Code` and `Runtime` on both `Resolver` and `Function`
constructs. Adds test covering basic JS resolver usage.

Author: MrArnoldPalmer

packages/@aws-cdk/aws-appsync/.gitignore

@@ -23,3 +23,5 @@ junit.xml
 !**/*.snapshot/**/asset.*/*.d.ts
 
 !**/*.snapshot/**/asset.*/**
+!test/appsync-js-resolver.js
+!test/appsync-js-pipeline.js

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,14 @@ export interface BaseAppsyncFunctionProps {
    * @default - no response mapping template
    */
   readonly responseMappingTemplate?: MappingTemplate;
+  /**
+   * The functions runtime
+   */
+  readonly runtime?: FunctionRuntime;
+  /**
+   * The function code
+   */
+  readonly code?: Code;
 }
 
 /**
@@ -128,11 +138,21 @@ 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');
+    }
+
+    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(),

packages/@aws-cdk/aws-appsync/lib/code.ts

@@ -0,0 +1,92 @@
+import * as cdk from '@aws-cdk/core';
+import { Construct } from 'constructs';
+import * as s3_assets from '@aws-cdk/aws-s3-assets';
+
+/**
+ * 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;
+}
+
+export abstract class Code {
+  /**
+   * Loads the function code from a local disk path.
+   *
+   * @param a 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);
+  }
+
+  public abstract bind(scope: Construct): CodeConfig;
+}
+
+export class AssetCode extends Code {
+  public readonly isInline = false;
+  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 {
+  public readonly isInline = true;
+
+  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,
+    };
+  }
+}

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';

packages/@aws-cdk/aws-appsync/lib/resolver.ts

@@ -1,12 +1,13 @@
 import { Token } from '@aws-cdk/core';
 import { Construct } from 'constructs';
-import { IAppsyncFunction } from './appsync-function';
+import { IAppsyncFunction, FunctionRuntime } from './appsync-function';
 import { CfnResolver } from './appsync.generated';
 import { CachingConfig } from './caching-config';
 import { BASE_CACHING_KEYS } from './caching-key';
 import { BaseDataSource } from './data-source';
 import { IGraphqlApi } from './graphqlapi-base';
 import { MappingTemplate } from './mapping-template';
+import { Code } from './code';
 
 /**
  * Basic properties for an AppSync resolver
@@ -51,6 +52,15 @@ export interface BaseResolverProps {
    * @default - No max batch size
    */
   readonly maxBatchSize?: number;
+
+  /**
+   * The functions runtime
+   */
+  readonly runtime?: FunctionRuntime;
+  /**
+   * The function code
+   */
+  readonly code?: Code;
 }
 
 /**
@@ -93,6 +103,11 @@ 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 (pipelineConfig && props.dataSource) {
       throw new Error(`Pipeline Resolver cannot have data source. Received: ${props.dataSource.name}`);
     }
@@ -108,12 +123,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,

packages/@aws-cdk/aws-appsync/lib/runtime.ts

@@ -0,0 +1,39 @@
+/**
+ * Appsync supported runtimes. Only JavaScript as of now
+ */
+export enum FunctionRuntimeFamily {
+  JS = 'APPSYNC_JS',
+}
+
+/**
+ * Utility class for specifying specific appsync runtime versions
+ */
+export class FunctionRuntime {
+  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() {
+    return {
+      name: this.name,
+      runtimeVersion: this.version,
+    };
+  }
+}
+

packages/@aws-cdk/aws-appsync/test/appsync-js-pipeline.js

@@ -0,0 +1,10 @@
+// The before step
+export function request(...args) {
+  console.log(args);
+  return {}
+}
+
+// The after step
+export function response(ctx) {
+  return ctx.prev.result
+}

packages/@aws-cdk/aws-appsync/test/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 JSON.stringify({
+    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 JSON.stringify(ctx.result)
+}

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

packages/@aws-cdk/aws-appsync/test/integ.js-resolver.js.snapshot/JsResolverIntegTestDefaultTestDeployAssert57AD8D20.assets.json

@@ -0,0 +1,19 @@
+{
+  "version": "22.0.0",
+  "files": {
+    "21fbb51d7b23f6a6c262b46a9caee79d744a3ac019fd45422d988b96d44b2a22": {
+      "source": {
+        "path": "JsResolverIntegTestDefaultTestDeployAssert57AD8D20.template.json",
+        "packaging": "file"
+      },
+      "destinations": {
+        "current_account-current_region": {
+          "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
+          "objectKey": "21fbb51d7b23f6a6c262b46a9caee79d744a3ac019fd45422d988b96d44b2a22.json",
+          "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
+        }
+      }
+    }
+  },
+  "dockerImages": {}
+}