@gradientedge/cdk-utils 6.9.0 → 6.10.1

package/dist/src/lib/construct/api-to-lambda-target/index.d.ts

@@ -0,0 +1 @@
+export * from './main';

package/dist/src/lib/construct/api-to-lambda-target/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./main"), exports);

package/dist/src/lib/construct/api-to-lambda-target/main.d.ts

@@ -0,0 +1,48 @@
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common';
+import * as types from '../../types/aws';
+export declare class ApiToLambdaTarget extends CommonConstruct {
+    props: types.ApiToLambdaTargetProps;
+    id: string;
+    applicationSecrets: secretsmanager.ISecret[];
+    apiToLambdaTargetRestApi: types.ApiToLambdaTargetRestApiType;
+    constructor(parent: Construct, id: string, props: types.ApiToLambdaTargetProps);
+    protected initResources(): void;
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     * @protected
+     */
+    protected resolveSecrets(): void;
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     * @protected
+     */
+    protected resolveHostedZone(): void;
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     * @protected
+     */
+    protected resolveCertificate(): void;
+    /**
+     * @summary Method to create rest restApi for Api
+     * @protected
+     */
+    protected createApiToLambdaTargetRestApi(): void;
+    /**
+     * @summary Method to create custom restApi domain for Api API
+     * @protected
+     */
+    protected createApiDomain(): void;
+    /**
+     * @summary Method to create base path mappings for GraphQL API
+     * @protected
+     */
+    protected createApiBasePathMapping(): void;
+    /**
+     * @summary Method to create route53 records for Api
+     * @protected
+     */
+    protected createApiRouteAssets(): void;
+}

package/dist/src/lib/construct/api-to-lambda-target/main.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiToLambdaTarget = void 0;
+const cdk = __importStar(require("aws-cdk-lib"));
+const apig = __importStar(require("aws-cdk-lib/aws-apigateway"));
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+const common_1 = require("../../common");
+const helper = __importStar(require("../../helper"));
+class ApiToLambdaTarget extends common_1.CommonConstruct {
+    props;
+    id;
+    /* application related resources */
+    applicationSecrets;
+    /* rest restApi related resources */
+    apiToLambdaTargetRestApi;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+        this.apiToLambdaTargetRestApi = new helper.ApiToLambdaTargetRestApi();
+    }
+    initResources() {
+        /* application related resources */
+        this.resolveSecrets();
+        /* core resources */
+        this.resolveHostedZone();
+        this.resolveCertificate();
+        /* restApi related resources */
+        this.createApiToLambdaTargetRestApi();
+        this.createApiDomain();
+        this.createApiBasePathMapping();
+        this.createApiRouteAssets();
+    }
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     * @protected
+     */
+    resolveSecrets() {
+        this.applicationSecrets = [];
+    }
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     * @protected
+     */
+    resolveHostedZone() {
+        this.apiToLambdaTargetRestApi.hostedZone = this.route53Manager.withHostedZoneFromFullyQualifiedDomainName(`${this.id}-hosted-zone`, this, this.props.useExistingHostedZone);
+    }
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     * @protected
+     */
+    resolveCertificate() {
+        if (this.props.api.useExisting)
+            return;
+        if (this.props.api.certificate.useExistingCertificate &&
+            this.props.api.certificate.certificateSsmName &&
+            this.props.api.certificate.certificateRegion) {
+            this.props.api.certificate.certificateArn = this.ssmManager.readStringParameterFromRegion(`${this.id}-certificate-param`, this, this.props.api.certificate.certificateSsmName, this.props.api.certificate.certificateRegion);
+        }
+        this.apiToLambdaTargetRestApi.certificate = this.acmManager.resolveCertificate(`${this.id}-certificate`, this, this.props.api.certificate);
+    }
+    /**
+     * @summary Method to create rest restApi for Api
+     * @protected
+     */
+    createApiToLambdaTargetRestApi() {
+        if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
+            this.apiToLambdaTargetRestApi.api = apig.RestApi.fromRestApiId(this, `${this.id}-rest-api`, cdk.Fn.importValue(this.props.api.importedRestApiRef));
+            return;
+        }
+        const accessLogGroup = this.logManager.createLogGroup(`${this.id}-rest-api-access-log`, this, {
+            logGroupName: `/custom/api/${this.id}-rest-api-access`,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.props.api.restApi = {
+            ...this.props.api.restApi,
+            ...{
+                deployOptions: {
+                    accessLogDestination: new apig.LogGroupLogDestination(accessLogGroup),
+                },
+            },
+        };
+        this.apiToLambdaTargetRestApi.api = this.apiManager.createLambdaRestApi(`${this.id}-lambda-rest-api`, this, this.props.api.restApi, lambda.Function.fromFunctionName(this, `${this.id}-lambda`, this.props.lambdaFunctionName));
+        this.addCfnOutput(`${this.id}-restApiId`, this.apiToLambdaTargetRestApi.api.restApiId);
+        this.addCfnOutput(`${this.id}-restApiRootResourceId`, this.apiToLambdaTargetRestApi.api.root.resourceId);
+    }
+    /**
+     * @summary Method to create custom restApi domain for Api API
+     * @protected
+     */
+    createApiDomain() {
+        if (this.props.api.useExisting)
+            return;
+        this.apiToLambdaTargetRestApi.domain = this.apiManager.createApiDomain(`${this.id}-api-domain`, this, this.isProductionStage() || this.props.skipStageForARecords
+            ? `${this.props.apiSubDomain}.${this.fullyQualifiedDomainName}`
+            : `${this.props.apiSubDomain}-${this.props.stage}.${this.fullyQualifiedDomainName}`, this.apiToLambdaTargetRestApi.certificate);
+    }
+    /**
+     * @summary Method to create base path mappings for GraphQL API
+     * @protected
+     */
+    createApiBasePathMapping() {
+        const apiRootPaths = this.props.apiRootPaths;
+        if (apiRootPaths && apiRootPaths.length > 0) {
+            apiRootPaths.forEach((apiRootPath) => {
+                this.apiToLambdaTargetRestApi.basePathMappings.push(new apig.BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
+                    basePath: apiRootPath,
+                    domainName: this.apiToLambdaTargetRestApi.domain,
+                    restApi: this.apiToLambdaTargetRestApi.api,
+                    stage: this.apiToLambdaTargetRestApi.api.deploymentStage,
+                }));
+            });
+            return;
+        }
+        // add default mapping if apiRootPaths not set
+        new apig.BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+            domainName: this.apiToLambdaTargetRestApi.domain,
+            restApi: this.apiToLambdaTargetRestApi.api,
+            stage: this.apiToLambdaTargetRestApi.api.deploymentStage,
+        });
+    }
+    /**
+     * @summary Method to create route53 records for Api
+     * @protected
+     */
+    createApiRouteAssets() {
+        if (this.props.api.useExisting)
+            return;
+        this.route53Manager.createApiGatewayARecord(`${this.id}-custom-domain-a-record`, this, this.props.apiSubDomain, this.apiToLambdaTargetRestApi.domain, this.apiToLambdaTargetRestApi.hostedZone, this.props.skipStageForARecords);
+    }
+}
+exports.ApiToLambdaTarget = ApiToLambdaTarget;

package/dist/src/lib/construct/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api-to-eventbridge-target';
 export * from './api-to-eventbridge-target-with-sns';
+export * from './api-to-lambda-target';
 export * from './graphql-api-lambda';
 export * from './graphql-api-lambda-with-cache';
 export * from './site-with-ecs-backend';

package/dist/src/lib/construct/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api-to-eventbridge-target"), exports);
 __exportStar(require("./api-to-eventbridge-target-with-sns"), exports);
+__exportStar(require("./api-to-lambda-target"), exports);
 __exportStar(require("./graphql-api-lambda"), exports);
 __exportStar(require("./graphql-api-lambda-with-cache"), exports);
 __exportStar(require("./site-with-ecs-backend"), exports);

package/dist/src/lib/helper/api-to-lambda-target-rest-api.d.ts

@@ -0,0 +1,36 @@
+import * as apig from 'aws-cdk-lib/aws-apigateway';
+import * as acm from 'aws-cdk-lib/aws-certificatemanager';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as route53 from 'aws-cdk-lib/aws-route53';
+import * as sns from 'aws-cdk-lib/aws-sns';
+import * as types from '../types/aws';
+/**
+ * @stability stable
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory member
+ * @classdesc Provides a construct to contain api resources for ApiToLambdaTarget
+ */
+export declare class ApiToLambdaTargetRestApi implements types.ApiToLambdaTargetRestApiType {
+    api: apig.RestApi;
+    basePathMappings: apig.BasePathMapping[];
+    certificate: acm.ICertificate;
+    domain: apig.DomainName;
+    errorResponseModel: apig.Model;
+    hostedZone: route53.IHostedZone;
+    integration: apig.Integration;
+    integrationErrorResponse: apig.IntegrationResponse;
+    integrationRequestParameters: {
+        [p: string]: string;
+    };
+    integrationRequestTemplates: {
+        [p: string]: string;
+    };
+    integrationResponse: apig.IntegrationResponse;
+    method: apig.Method;
+    methodErrorResponse: apig.MethodResponse;
+    methodResponse: apig.MethodResponse;
+    resource: apig.Resource;
+    responseModel: apig.Model;
+    topic: sns.Topic;
+    role: iam.Role;
+}

package/dist/src/lib/helper/api-to-lambda-target-rest-api.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiToLambdaTargetRestApi = void 0;
+/**
+ * @stability stable
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory member
+ * @classdesc Provides a construct to contain api resources for ApiToLambdaTarget
+ */
+class ApiToLambdaTargetRestApi {
+    api;
+    basePathMappings = [];
+    certificate;
+    domain;
+    errorResponseModel;
+    hostedZone;
+    integration;
+    integrationErrorResponse;
+    integrationRequestParameters;
+    integrationRequestTemplates;
+    integrationResponse;
+    method;
+    methodErrorResponse;
+    methodResponse;
+    resource;
+    responseModel;
+    topic;
+    role;
+}
+exports.ApiToLambdaTargetRestApi = ApiToLambdaTargetRestApi;

package/dist/src/lib/helper/index.d.ts

@@ -1,2 +1,3 @@
 export * from './api-to-eventbridge-target-event';
 export * from './api-to-eventbridge-target-rest-api';
+export * from './api-to-lambda-target-rest-api';

package/dist/src/lib/helper/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api-to-eventbridge-target-event"), exports);
 __exportStar(require("./api-to-eventbridge-target-rest-api"), exports);
+__exportStar(require("./api-to-lambda-target-rest-api"), exports);

package/dist/src/lib/manager/aws/api-manager.d.ts

@@ -31,7 +31,7 @@ export declare class ApiManager {
      * @param {AcmProps} props lambda rest restApi props
      * @param lambdaFunction
      */
-    createLambdaRestApi(id: string, scope: common.CommonConstruct, props: apig.LambdaRestApiProps, lambdaFunction: lambda.Function): apig.LambdaRestApi;
+    createLambdaRestApi(id: string, scope: common.CommonConstruct, props: apig.LambdaRestApiProps, lambdaFunction: lambda.IFunction): apig.LambdaRestApi;
     /**
      * @summary Method to create custom restApi domain
      * @param {string} id scoped id of the resource

package/dist/src/lib/types/aws/index.d.ts

@@ -272,6 +272,36 @@ export interface ApiToEventBridgeTargetRestApiType {
     role?: iam.Role;
     policy?: iam.PolicyDocument;
 }
+/**
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory Types
+ */
+export interface ApiToLambdaTargetRestApiType {
+    api: apig.IRestApi;
+    authoriser?: apig.IAuthorizer;
+    basePathMappings: apig.BasePathMapping[];
+    certificate: acm.ICertificate;
+    domain: apig.DomainName;
+    errorResponseModel: apig.Model;
+    hostedZone: route53.IHostedZone;
+    integration: apig.Integration;
+    integrationErrorResponse: apig.IntegrationResponse;
+    integrationRequestParameters: {
+        [p: string]: string;
+    };
+    integrationRequestTemplates: {
+        [p: string]: string;
+    };
+    integrationResponse: apig.IntegrationResponse;
+    method: apig.Method;
+    methodErrorResponse: apig.MethodResponse;
+    methodResponse: apig.MethodResponse;
+    resource: apig.Resource;
+    responseModel: apig.Model;
+    topic?: sns.ITopic;
+    role?: iam.Role;
+    policy?: iam.PolicyDocument;
+}
 /**
  * @category cdk-utils.api-to-eventbridge-target
  * @subcategory Types
@@ -345,6 +375,31 @@ export interface ApiToEventBridgeTargetProps extends CommonStackProps {
     timezone: string;
     useExistingHostedZone: boolean;
 }
+/**
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory Properties
+ */
+export interface ApiToLambdaTargetRestApiProps {
+    certificate: AcmProps;
+    restApi: apig.LambdaRestApiProps;
+    importedRestApiRef?: string;
+    importedRestApiRootResourceRef?: string;
+    useExisting: boolean;
+}
+/**
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory Properties
+ */
+export interface ApiToLambdaTargetProps extends CommonStackProps {
+    apiRootPaths?: string[];
+    apiSubDomain: string;
+    api: ApiToLambdaTargetRestApiProps;
+    lambdaFunctionName: string;
+    logLevel: string;
+    nodeEnv: string;
+    timezone: string;
+    useExistingHostedZone: boolean;
+}
 /**
  * @category cdk-utils.acm-manager
  * @subcategory Properties

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradientedge/cdk-utils",
-  "version": "6.9.0",
+  "version": "6.10.1",
   "description": "Utilities for AWS CDK provisioning",
   "main": "dist/index.js",
   "engines": {

package/src/lib/construct/api-to-lambda-target/index.ts

@@ -0,0 +1 @@
+export * from './main'

package/src/lib/construct/api-to-lambda-target/main.ts

@@ -0,0 +1,189 @@
+import * as cdk from 'aws-cdk-lib'
+import * as apig from 'aws-cdk-lib/aws-apigateway'
+import * as lambda from 'aws-cdk-lib/aws-lambda'
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager'
+import { Construct } from 'constructs'
+import { CommonConstruct } from '../../common'
+import * as helper from '../../helper'
+import * as types from '../../types/aws'
+
+export class ApiToLambdaTarget extends CommonConstruct {
+  props: types.ApiToLambdaTargetProps
+  id: string
+
+  /* application related resources */
+  applicationSecrets: secretsmanager.ISecret[]
+
+  /* rest restApi related resources */
+  apiToLambdaTargetRestApi: types.ApiToLambdaTargetRestApiType
+
+  constructor(parent: Construct, id: string, props: types.ApiToLambdaTargetProps) {
+    super(parent, id, props)
+
+    this.props = props
+    this.id = id
+
+    this.apiToLambdaTargetRestApi = new helper.ApiToLambdaTargetRestApi()
+  }
+
+  protected initResources() {
+    /* application related resources */
+    this.resolveSecrets()
+
+    /* core resources */
+    this.resolveHostedZone()
+    this.resolveCertificate()
+
+    /* restApi related resources */
+    this.createApiToLambdaTargetRestApi()
+    this.createApiDomain()
+    this.createApiBasePathMapping()
+    this.createApiRouteAssets()
+  }
+
+  /**
+   * @summary Method to resolve secrets from SecretsManager
+   * - To be implemented in the overriding method in the implementation class
+   * @protected
+   */
+  protected resolveSecrets() {
+    this.applicationSecrets = []
+  }
+
+  /**
+   * @summary Method to resolve a hosted zone based on domain attributes
+   * @protected
+   */
+  protected resolveHostedZone() {
+    this.apiToLambdaTargetRestApi.hostedZone = this.route53Manager.withHostedZoneFromFullyQualifiedDomainName(
+      `${this.id}-hosted-zone`,
+      this,
+      this.props.useExistingHostedZone
+    )
+  }
+
+  /**
+   * @summary Method to resolve a certificate based on attributes
+   * @protected
+   */
+  protected resolveCertificate() {
+    if (this.props.api.useExisting) return
+    if (
+      this.props.api.certificate.useExistingCertificate &&
+      this.props.api.certificate.certificateSsmName &&
+      this.props.api.certificate.certificateRegion
+    ) {
+      this.props.api.certificate.certificateArn = this.ssmManager.readStringParameterFromRegion(
+        `${this.id}-certificate-param`,
+        this,
+        this.props.api.certificate.certificateSsmName,
+        this.props.api.certificate.certificateRegion
+      )
+    }
+
+    this.apiToLambdaTargetRestApi.certificate = this.acmManager.resolveCertificate(
+      `${this.id}-certificate`,
+      this,
+      this.props.api.certificate
+    )
+  }
+
+  /**
+   * @summary Method to create rest restApi for Api
+   * @protected
+   */
+  protected createApiToLambdaTargetRestApi() {
+    if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
+      this.apiToLambdaTargetRestApi.api = apig.RestApi.fromRestApiId(
+        this,
+        `${this.id}-rest-api`,
+        cdk.Fn.importValue(this.props.api.importedRestApiRef)
+      )
+      return
+    }
+
+    const accessLogGroup = this.logManager.createLogGroup(`${this.id}-rest-api-access-log`, this, {
+      logGroupName: `/custom/api/${this.id}-rest-api-access`,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    })
+
+    this.props.api.restApi = {
+      ...this.props.api.restApi,
+      ...{
+        deployOptions: {
+          accessLogDestination: new apig.LogGroupLogDestination(accessLogGroup),
+        },
+      },
+    }
+
+    this.apiToLambdaTargetRestApi.api = this.apiManager.createLambdaRestApi(
+      `${this.id}-lambda-rest-api`,
+      this,
+      this.props.api.restApi,
+      lambda.Function.fromFunctionName(this, `${this.id}-lambda`, this.props.lambdaFunctionName)
+    )
+
+    this.addCfnOutput(`${this.id}-restApiId`, this.apiToLambdaTargetRestApi.api.restApiId)
+    this.addCfnOutput(`${this.id}-restApiRootResourceId`, this.apiToLambdaTargetRestApi.api.root.resourceId)
+  }
+
+  /**
+   * @summary Method to create custom restApi domain for Api API
+   * @protected
+   */
+  protected createApiDomain() {
+    if (this.props.api.useExisting) return
+    this.apiToLambdaTargetRestApi.domain = this.apiManager.createApiDomain(
+      `${this.id}-api-domain`,
+      this,
+      this.isProductionStage() || this.props.skipStageForARecords
+        ? `${this.props.apiSubDomain}.${this.fullyQualifiedDomainName}`
+        : `${this.props.apiSubDomain}-${this.props.stage}.${this.fullyQualifiedDomainName}`,
+      this.apiToLambdaTargetRestApi.certificate
+    )
+  }
+
+  /**
+   * @summary Method to create base path mappings for GraphQL API
+   * @protected
+   */
+  protected createApiBasePathMapping() {
+    const apiRootPaths = this.props.apiRootPaths
+    if (apiRootPaths && apiRootPaths.length > 0) {
+      apiRootPaths.forEach((apiRootPath: string) => {
+        this.apiToLambdaTargetRestApi.basePathMappings.push(
+          new apig.BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
+            basePath: apiRootPath,
+            domainName: this.apiToLambdaTargetRestApi.domain,
+            restApi: this.apiToLambdaTargetRestApi.api,
+            stage: this.apiToLambdaTargetRestApi.api.deploymentStage,
+          })
+        )
+      })
+      return
+    }
+
+    // add default mapping if apiRootPaths not set
+    new apig.BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+      domainName: this.apiToLambdaTargetRestApi.domain,
+      restApi: this.apiToLambdaTargetRestApi.api,
+      stage: this.apiToLambdaTargetRestApi.api.deploymentStage,
+    })
+  }
+
+  /**
+   * @summary Method to create route53 records for Api
+   * @protected
+   */
+  protected createApiRouteAssets() {
+    if (this.props.api.useExisting) return
+    this.route53Manager.createApiGatewayARecord(
+      `${this.id}-custom-domain-a-record`,
+      this,
+      this.props.apiSubDomain,
+      this.apiToLambdaTargetRestApi.domain,
+      this.apiToLambdaTargetRestApi.hostedZone,
+      this.props.skipStageForARecords
+    )
+  }
+}

package/src/lib/construct/index.ts

@@ -1,5 +1,6 @@
 export * from './api-to-eventbridge-target'
 export * from './api-to-eventbridge-target-with-sns'
+export * from './api-to-lambda-target'
 export * from './graphql-api-lambda'
 export * from './graphql-api-lambda-with-cache'
 export * from './site-with-ecs-backend'

package/src/lib/helper/api-to-lambda-target-rest-api.ts

@@ -0,0 +1,33 @@
+import * as apig from 'aws-cdk-lib/aws-apigateway'
+import * as acm from 'aws-cdk-lib/aws-certificatemanager'
+import * as iam from 'aws-cdk-lib/aws-iam'
+import * as route53 from 'aws-cdk-lib/aws-route53'
+import * as sns from 'aws-cdk-lib/aws-sns'
+import * as types from '../types/aws'
+
+/**
+ * @stability stable
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory member
+ * @classdesc Provides a construct to contain api resources for ApiToLambdaTarget
+ */
+export class ApiToLambdaTargetRestApi implements types.ApiToLambdaTargetRestApiType {
+  api: apig.RestApi
+  basePathMappings: apig.BasePathMapping[] = []
+  certificate: acm.ICertificate
+  domain: apig.DomainName
+  errorResponseModel: apig.Model
+  hostedZone: route53.IHostedZone
+  integration: apig.Integration
+  integrationErrorResponse: apig.IntegrationResponse
+  integrationRequestParameters: { [p: string]: string }
+  integrationRequestTemplates: { [p: string]: string }
+  integrationResponse: apig.IntegrationResponse
+  method: apig.Method
+  methodErrorResponse: apig.MethodResponse
+  methodResponse: apig.MethodResponse
+  resource: apig.Resource
+  responseModel: apig.Model
+  topic: sns.Topic
+  role: iam.Role
+}

package/src/lib/helper/index.ts

@@ -1,2 +1,3 @@
 export * from './api-to-eventbridge-target-event'
 export * from './api-to-eventbridge-target-rest-api'
+export * from './api-to-lambda-target-rest-api'

package/src/lib/manager/aws/api-manager.ts

@@ -37,7 +37,7 @@ export class ApiManager {
     id: string,
     scope: common.CommonConstruct,
     props: apig.LambdaRestApiProps,
-    lambdaFunction: lambda.Function
+    lambdaFunction: lambda.IFunction
   ) {
     const api = new apig.LambdaRestApi(scope, `${id}`, {
       binaryMediaTypes: props.binaryMediaTypes,

package/src/lib/types/aws/index.ts

@@ -288,6 +288,33 @@ export interface ApiToEventBridgeTargetRestApiType {
   policy?: iam.PolicyDocument
 }
 
+/**
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory Types
+ */
+export interface ApiToLambdaTargetRestApiType {
+  api: apig.IRestApi
+  authoriser?: apig.IAuthorizer
+  basePathMappings: apig.BasePathMapping[]
+  certificate: acm.ICertificate
+  domain: apig.DomainName
+  errorResponseModel: apig.Model
+  hostedZone: route53.IHostedZone
+  integration: apig.Integration
+  integrationErrorResponse: apig.IntegrationResponse
+  integrationRequestParameters: { [p: string]: string }
+  integrationRequestTemplates: { [p: string]: string }
+  integrationResponse: apig.IntegrationResponse
+  method: apig.Method
+  methodErrorResponse: apig.MethodResponse
+  methodResponse: apig.MethodResponse
+  resource: apig.Resource
+  responseModel: apig.Model
+  topic?: sns.ITopic
+  role?: iam.Role
+  policy?: iam.PolicyDocument
+}
+
 /**
  * @category cdk-utils.api-to-eventbridge-target
  * @subcategory Types
@@ -366,6 +393,33 @@ export interface ApiToEventBridgeTargetProps extends CommonStackProps {
   useExistingHostedZone: boolean
 }
 
+/**
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory Properties
+ */
+export interface ApiToLambdaTargetRestApiProps {
+  certificate: AcmProps
+  restApi: apig.LambdaRestApiProps
+  importedRestApiRef?: string
+  importedRestApiRootResourceRef?: string
+  useExisting: boolean
+}
+
+/**
+ * @category cdk-utils.api-to-lambda-target
+ * @subcategory Properties
+ */
+export interface ApiToLambdaTargetProps extends CommonStackProps {
+  apiRootPaths?: string[]
+  apiSubDomain: string
+  api: ApiToLambdaTargetRestApiProps
+  lambdaFunctionName: string
+  logLevel: string
+  nodeEnv: string
+  timezone: string
+  useExistingHostedZone: boolean
+}
+
 /**
  * @category cdk-utils.acm-manager
  * @subcategory Properties