feat(api-gateway): support instantiating ApiIntegrations directly

Author: Brendan McKee

src/api.ts

@@ -74,15 +74,24 @@ type IntegrationTarget<IntegrationRequest, IntegrationResponse> =
   | Function<IntegrationRequest, IntegrationResponse>
   | ExpressStepFunction<IntegrationRequest, IntegrationResponse>;
 
-interface BaseApiIntegration {
+export abstract class BaseApiIntegration {
+  /**
+   * Identify subclasses as API integrations to the Functionless plugin
+   */
+  public static readonly FunctionlessType = "ApiIntegration";
+  protected readonly functionlessKind = BaseApiIntegration.FunctionlessType;
+
   /**
    * Add this integration as a Method to an API Gateway resource.
    *
    * TODO: this mirrors the AppsyncResolver.addResolver method, but it
    * is on the chopping block: https://github.com/functionless/functionless/issues/137
    * The 2 classes are conceptually similar so we should keep the DX in sync.
    */
-  addMethod(httpMethod: HttpMethod, resource: aws_apigateway.Resource): void;
+  public abstract addMethod(
+    httpMethod: HttpMethod,
+    resource: aws_apigateway.Resource
+  ): void;
 }
 
 /**
@@ -158,17 +167,12 @@ export interface MockApiIntegrationProps<
  */
 export class MockApiIntegration<
   Props extends MockApiIntegrationProps<any, any, any>
-> implements BaseApiIntegration
-{
-  /**
-   * This static property identifies this class as a MockApiIntegration to the Functionless plugin.
-   */
-  public static readonly FunctionlessType = "MockApiIntegration";
-
+> extends BaseApiIntegration {
   private readonly request: FunctionDecl;
   private readonly responses: { [K in keyof Props["responses"]]: FunctionDecl };
 
   public constructor(props: Props) {
+    super();
     this.request = validateFunctionDecl(props.request);
     this.responses = Object.fromEntries(
       Object.entries(props.responses).map(([k, v]) => [
@@ -251,18 +255,13 @@ export interface AwsApiIntegrationProps<
  */
 export class AwsApiIntegration<
   Props extends AwsApiIntegrationProps<any, any, any, any>
-> implements BaseApiIntegration
-{
-  /**
-   * This static property identifies this class as an AwsApiIntegration to the Functionless plugin.
-   */
-  public static readonly FunctionlessType = "AwsApiIntegration";
-
+> extends BaseApiIntegration {
   private readonly request: FunctionDecl;
   private readonly response: FunctionDecl;
   private readonly integration: Props["integration"];
 
   constructor(props: Props) {
+    super();
     this.request = validateFunctionDecl(props.request);
     this.response = validateFunctionDecl(props.response);
     this.integration = props.integration;

src/checker.ts

@@ -1,5 +1,6 @@
 import * as ts from "typescript";
 import * as tsserver from "typescript/lib/tsserverlibrary";
+import { BaseApiIntegration } from "./api";
 import { AppsyncResolver } from "./appsync";
 import { EventBus, EventBusRule } from "./event-bridge";
 import { EventBusTransform } from "./event-bridge/transform";
@@ -59,6 +60,10 @@ export type ApiIntegrationsStaticMethodInterface = ts.CallExpression & {
   arguments: [ts.ObjectLiteralExpression];
 };
 
+export type ApiIntegrationInterface = ts.NewExpression & {
+  arguments: [ts.ObjectLiteralExpression];
+};
+
 export type FunctionlessChecker = ReturnType<typeof makeFunctionlessChecker>;
 
 export function makeFunctionlessChecker(
@@ -77,6 +82,7 @@ export function makeFunctionlessChecker(
     isStepFunction,
     isNewFunctionlessFunction,
     isApiIntegrationsStaticMethod,
+    isApiIntegration,
     isCDKConstruct,
     getFunctionlessTypeKind,
   };
@@ -231,6 +237,16 @@ export function makeFunctionlessChecker(
     return x;
   }
 
+  function isApiIntegration(node: ts.Node): node is ApiIntegrationInterface {
+    return (
+      ts.isNewExpression(node) &&
+      isFunctionlessClassOfKind(
+        node.expression,
+        BaseApiIntegration.FunctionlessType
+      )
+    );
+  }
+
   /**
    * Heuristically evaluate the fqn of a symbol to be in a module and of a type name.
    *

src/compile.ts

@@ -4,6 +4,7 @@ import type { PluginConfig, TransformerExtras } from "ts-patch";
 import ts from "typescript";
 import { assertDefined } from "./assert";
 import {
+  ApiIntegrationInterface,
   ApiIntegrationsStaticMethodInterface,
   EventBusMapInterface,
   EventBusRuleInterface,
@@ -117,6 +118,8 @@ export function compile(
             return visitFunction(node, ctx);
           } else if (checker.isApiIntegrationsStaticMethod(node)) {
             return visitApiIntegrationsStaticMethod(node);
+          } else if (checker.isApiIntegration(node)) {
+            return visitApiIntegration(node);
           }
           return node;
         };
@@ -533,7 +536,29 @@ export function compile(
       ): ts.CallExpression {
         const [props] = node.arguments;
 
-        const updatedProps = ts.factory.updateObjectLiteralExpression(
+        return ts.factory.updateCallExpression(
+          node,
+          node.expression,
+          node.typeArguments,
+          [visitApiIntegrationProps(props)]
+        );
+      }
+
+      function visitApiIntegration(node: ApiIntegrationInterface): ts.Node {
+        const [props] = node.arguments;
+
+        return ts.factory.updateNewExpression(
+          node,
+          node.expression,
+          node.typeArguments,
+          [visitApiIntegrationProps(props)]
+        );
+      }
+
+      function visitApiIntegrationProps(
+        props: ts.ObjectLiteralExpression
+      ): ts.ObjectLiteralExpression {
+        return ts.factory.updateObjectLiteralExpression(
           props,
           props.properties.map((prop) => {
             if (
@@ -552,13 +577,6 @@ export function compile(
             return prop;
           })
         );
-
-        return ts.factory.updateCallExpression(
-          node,
-          node.expression,
-          node.typeArguments,
-          [updatedProps]
-        );
       }
 
       function visitApiIntegrationMapperProp(