feat(appsync): remove addResolver from AppsyncResolver and lazy template evaluation

src/appsync.ts

@@ -1,4 +1,5 @@
 import * as appsync from "@aws-cdk/aws-appsync-alpha";
+import { aws_appsync, Lazy } from "aws-cdk-lib";
 import type { AppSyncResolverEvent } from "aws-lambda";
 import { Construct } from "constructs";
 import {
@@ -32,7 +33,12 @@ import {
 import { findDeepIntegration, IntegrationImpl } from "./integration";
 import { Literal } from "./literal";
 import { FunctionlessNode } from "./node";
-import { AnyFunction, isInTopLevelScope, singletonConstruct } from "./util";
+import {
+  AnyFunction,
+  isInTopLevelScope,
+  memoize,
+  singletonConstruct,
+} from "./util";
 import { visitEachChild } from "./visit";
 import { VTL } from "./vtl";
 
@@ -131,6 +137,18 @@ export class AppsyncVTL extends VTL {
   }
 }
 
+export interface AppsyncResolverProps<
+  Arguments extends ResolverArguments,
+  Result,
+  Source = undefined
+> extends Pick<
+    appsync.BaseResolverProps,
+    "typeName" | "fieldName" | "cachingConfig"
+  > {
+  readonly api: appsync.GraphqlApi;
+  readonly resolve: ResolverFunction<Arguments, Result, Source>;
+}
+
 /**
  * An AWS AppSync Resolver Function derived from TypeScript syntax.
  *
@@ -170,7 +188,7 @@ export class AppsyncResolver<
   Arguments extends ResolverArguments,
   Result,
   Source = undefined
-> {
+> extends Construct {
   /**
    * This static property identifies this class as an AppsyncResolver to the TypeScript plugin.
    */
@@ -180,62 +198,36 @@ export class AppsyncResolver<
     ResolverFunction<Arguments, Result, Source>
   >;
 
-  constructor(fn: ResolverFunction<Arguments, Result, Source>) {
-    this.decl = validateFunctionDecl(fn, "AppsyncResolver");
-  }
+  public readonly resource;
+  public readonly resolvers;
 
-  /**
-   * Generate and add an AWS Appsync Resolver to an AWS Appsync GraphQL API.
-   *
-   * ```ts
-   * import * as appsync from "@aws-cdk/aws-appsync-alpha";
-   *
-   * const api = new appsync.GraphQLApi(..);
-   *
-   * ```ts
-   * const getPerson = new AppsyncResolver<{id: string}, Person | undefined>(
-   *   ($context, id) => {
-   *     const person = table.get({
-   *       key: {
-   *         id: $util.toDynamoDB(id)
-   *       }
-   *     });
-   *     return person;
-   *   });
-   * ```
-   *
-   * getPerson.createResolver(api, {
-   *   typeName: "Query",
-   *   fieldName: "getPerson"
-   * });
-   * ```
-   *
-   * @param api the AWS Appsync API to add this Resolver to
-   * @param options typeName, fieldName and cachingConfig for this Resolver.
-   * @returns a reference to the generated {@link appsync.Resolver}.
-   */
-  public addResolver(
-    api: appsync.GraphqlApi,
-    options: Pick<
-      appsync.BaseResolverProps,
-      "typeName" | "fieldName" | "cachingConfig"
-    >
-  ): SynthesizedAppsyncResolver {
-    const fields = this.getResolvableFields(api);
-
-    return new SynthesizedAppsyncResolver(
-      api,
-      `${options.typeName}${options.fieldName}Resolver`,
-      {
-        ...options,
-        api,
-        templates: fields.templates,
-        dataSource: fields.dataSource,
-        requestMappingTemplate: fields.requestMappingTemplate,
-        responseMappingTemplate: fields.responseMappingTemplate,
-        pipelineConfig: fields.pipelineConfig,
-      }
-    );
+  constructor(
+    scope: Construct,
+    id: string,
+    props: AppsyncResolverProps<Arguments, Result, Source>
+  ) {
+    super(scope, id);
+    this.decl = validateFunctionDecl(props.resolve, "AppsyncResolver");
+
+    this.resolvers = memoize(() => this.synthResolvers(props.api));
+
+    this.resource = new aws_appsync.CfnResolver(this, "Resource", {
+      apiId: props.api.apiId,
+      typeName: props.typeName,
+      fieldName: props.fieldName,
+      requestMappingTemplate: Lazy.string({
+        produce: () => this.resolvers().requestMappingTemplate.renderTemplate(),
+      }),
+      pipelineConfig: {
+        functions: Lazy.list({
+          produce: () => this.resolvers().templates,
+        }),
+      },
+      responseMappingTemplate: Lazy.string({
+        produce: () =>
+          this.resolvers().responseMappingTemplate.renderTemplate(),
+      }),
+    });
   }
 
   /**
@@ -279,11 +271,11 @@ export class AppsyncResolver<
       appsync.ResolvableFieldOptions,
       | "returnType"
       | keyof ReturnType<
-          AppsyncResolver<Arguments, Result, Source>["getResolvableFields"]
+          AppsyncResolver<Arguments, Result, Source>["synthResolvers"]
         >
     >
   ): appsync.ResolvableField {
-    const fields = this.getResolvableFields(api);
+    const fields = this.synthResolvers(api);
 
     return new appsync.ResolvableField({
       ...options,
@@ -295,7 +287,7 @@ export class AppsyncResolver<
     });
   }
 
-  private getResolvableFields(api: appsync.GraphqlApi) {
+  private synthResolvers(api: appsync.GraphqlApi) {
     const resolverCount = countResolvers(this.decl);
 
     const [pipelineConfig, responseMappingTemplate, innerTemplates] =

src/compile.ts

@@ -220,14 +220,45 @@ export function compile(
       }
 
       function visitAppsyncResolver(call: ts.NewExpression): ts.Node {
-        if (call.arguments?.length === 1) {
-          const impl = call.arguments[0];
-          if (ts.isFunctionExpression(impl) || ts.isArrowFunction(impl)) {
+        if (call.arguments?.length === 3) {
+          const [scope, id, props] = call.arguments;
+          if (ts.isObjectLiteralExpression(props)) {
             return ts.factory.updateNewExpression(
               call,
               call.expression,
               call.typeArguments,
-              [errorBoundary(() => toFunction("FunctionDecl", impl, 1))]
+              [
+                scope,
+                id,
+                ts.factory.updateObjectLiteralExpression(
+                  props,
+                  props.properties.map((prop) => {
+                    if (ts.isPropertyAssignment(prop)) {
+                      if (
+                        (ts.isIdentifier(prop.name) &&
+                          prop.name.text === "resolve") ||
+                        (ts.isStringLiteral(prop.name) &&
+                          prop.name.text === "resolve")
+                      ) {
+                        const impl = prop.initializer;
+                        if (
+                          ts.isFunctionExpression(impl) ||
+                          ts.isArrowFunction(impl)
+                        ) {
+                          return ts.factory.updatePropertyAssignment(
+                            prop,
+                            prop.name,
+                            errorBoundary(() =>
+                              toFunction("FunctionDecl", impl, 1)
+                            )
+                          );
+                        }
+                      }
+                    }
+                    return prop;
+                  })
+                ),
+              ]
             );
           }
         }

src/util.ts

@@ -27,6 +27,24 @@ import { FunctionlessNode } from "./node";
 
 export type AnyFunction = (...args: any[]) => any;
 
+/**
+ * Create a memoized function.
+ *
+ * @param f the function that produces the value
+ * @returns a function that computes a value on demand at most once.
+ */
+export function memoize<T>(f: () => T): () => T {
+  let isComputed = false;
+  let t: T;
+  return () => {
+    if (!isComputed) {
+      t = f();
+      isComputed = true;
+    }
+    return t!;
+  };
+}
+
 export function isInTopLevelScope(expr: FunctionlessNode): boolean {
   if (expr.parent === undefined) {
     return true;

test-app/src/app.ts

@@ -28,32 +28,8 @@ const api = new appsync.GraphqlApi(stack, "Api", {
 });
 
 // @ts-ignore
-const peopleDb = new PeopleDatabase(stack, "PeopleDB");
-
-peopleDb.getPerson.addResolver(api, {
-  typeName: "Query",
-  fieldName: "getPerson",
-});
-
-peopleDb.addPerson.addResolver(api, {
-  typeName: "Mutation",
-  fieldName: "addPerson",
-});
-
-// add a duplicate addPerson API to test duplicates
-peopleDb.addPerson.addResolver(api, {
-  typeName: "Mutation",
-  fieldName: "addPerson2",
-});
-
-peopleDb.updateName.addResolver(api, {
-  typeName: "Mutation",
-  fieldName: "updateName",
-});
-
-peopleDb.deletePerson.addResolver(api, {
-  typeName: "Mutation",
-  fieldName: "deletePerson",
+const peopleDb = new PeopleDatabase(stack, "PeopleDB", {
+  api,
 });
 
 interface MyEventDetails {