API Gateway Construct

// examples/MyStack.ts
import { Construct } from 'constructs';
import { App, TerraformStack, TerraformOutput } from 'cdktf';
import * as aws from '@cdktf/provider-aws';
import { LambdaFunction } from './constructs/LambdaFunction';
import { LambdaRestApi } from './constructs/LambdaRestApi';

class MyStack extends TerraformStack {
  constructor(scope: Construct, id: string) {
    super(scope, id);

    // AWS provider for the stack
    new aws.AwsProvider(this, 'aws-provider', {
      region: 'us-east-1',
    });

    // Create the Lambda function (custom construct)
    const lambdaFn = new LambdaFunction(this, 'lambda-function', {
      functionName: 'cdktf-name-picker-api',
      bundle: './function-name-picker',
      handler: 'index.handler',
    });

    // Create the API Gateway construct, attach the Lambda, and expose the URL
    const api = new LambdaRestApi(this, 'lambda-rest-api', {
      handler: lambdaFn,
      stageName: 'dev',
    });

    // Output the API URL
    new TerraformOutput(this, 'apiUrl', {
      value: api.url,
    });
  }
}

const app = new App();
new MyStack(app, 'cdktf-name-picker');
app.synth();

// utils/utils.ts
import { TerraformStack } from 'cdktf';
import { Construct } from 'constructs';

/**
 * Build a construct name prefixed with the current Terraform stack id.
 * Example: "<stack-id>-rest-api"
 */
export const getConstructName = (scope: Construct, id: string) =>
  `${TerraformStack.of(scope).id}-${id}`;

// constructs/LambdaRestApi.ts
import { Construct } from 'constructs';
import * as aws from '@cdktf/provider-aws';
import { getConstructName } from '../utils/utils';

interface LambdaRestApiProps {
  // handler should be the construct instance that represents the Lambda function.
  // Type can be adjusted to the exact Lambda construct type you use.
  handler: any;
  stageName: string;
}

export class LambdaRestApi extends Construct {
  public readonly url: string;

  constructor(scope: Construct, id: string, { handler, stageName }: LambdaRestApiProps) {
    super(scope, id);

    // Create the REST API
    const restApi = new aws.ApiGatewayRestApi(this, 'rest-api', {
      name: getConstructName(this, 'rest-api'),
    });

    // Attach ANY method to the root resource (proxy to Lambda)
    this.createApiGatewayLambdaMethod('root', restApi, restApi.rootResourceId, handler);

    // Create a proxy resource to handle all sub-paths: /{proxy+}
    const proxyResource = new aws.ApiGatewayResource(this, 'proxy-resource', {
      restApiId: restApi.id,
      parentId: restApi.rootResourceId,
      pathPart: '{proxy+}',
    });

    // Attach ANY method to the proxy resource (proxy to Lambda)
    this.createApiGatewayLambdaMethod('proxy-resource', restApi, proxyResource.id, handler);

    // Allow API Gateway to invoke the Lambda function
    new aws.LambdaPermission(this, 'api-gateway-permission', {
      action: 'lambda:InvokeFunction',
      functionName: handler.functionName,
      principal: 'apigateway.amazonaws.com',
      sourceArn: `${restApi.executionArn}/*/*`,
    });

    // Deploy the API to the specified stage
    new aws.ApiGatewayDeployment(this, 'deployment', {
      restApiId: restApi.id,
      stageName,
      // dependsOn ensures the deployment occurs after resources and methods are created
      dependsOn: [proxyResource, handler],
    });

    // Construct and expose the invoke URL for the API Gateway REST API.
    // This assumes the provider region is 'us-east-1' as in the example stack.
    // Adjust the region as needed or derive it from the provider configuration.
    this.url = `https://${restApi.id}.execute-api.us-east-1.amazonaws.com/${stageName}`;
  }

  /**
   * Helper to add an ANY method and an AWS_PROXY integration pointing to the given Lambda.
   */
  private createApiGatewayLambdaMethod(
    idPrefix: string,
    restApi: aws.ApiGatewayRestApi,
    resourceId: string,
    apiLambda: any
  ) {
    // Create an ANY method without authorization
    new aws.ApiGatewayMethod(this, `${idPrefix}-method`, {
      restApiId: restApi.id,
      resourceId,
      httpMethod: 'ANY',
      authorization: 'NONE',
    });

    // Create an AWS_PROXY integration forwarding the request to Lambda (integrationHttpMethod = POST)
    new aws.ApiGatewayIntegration(this, `${idPrefix}-lambda-integration`, {
      restApiId: restApi.id,
      resourceId,
      httpMethod: 'ANY',
      integrationHttpMethod: 'POST',
      type: 'AWS_PROXY',
      uri: apiLambda.invokeArn,
    });
  }
}