@gradientedge/cdk-utils 10.8.0 → 11.0.0

package/src/lib/aws/common/construct.ts

@@ -1,167 +0,0 @@
-import { CfnOutput } from 'aws-cdk-lib'
-import { Construct } from 'constructs'
-import { isDevStage, isPrdStage, isTestStage, isUatStage } from '../../common/index.js'
-import {
-  AcmManager,
-  ApiManager,
-  AppConfigManager,
-  CloudFrontManager,
-  CloudTrailManager,
-  CloudWatchManager,
-  CodeBuildManager,
-  DynamodbManager,
-  EcrManager,
-  EcsManager,
-  EfsManager,
-  EksManager,
-  ElastiCacheManager,
-  EventManager,
-  EventTargetManager,
-  EvidentlyManager,
-  IamManager,
-  KmsManager,
-  LambdaManager,
-  LogManager,
-  Route53Manager,
-  S3Manager,
-  SecretsManager,
-  SfnManager,
-  SnsManager,
-  SqsManager,
-  SsmManager,
-  VpcManager,
-  WafManager,
-} from '../services/index.js'
-import { createCfnOutput } from '../utils/index.js'
-import { ResourceNameFormatter } from './resource-name-formatter.js'
-import { CommonStackProps } from './types.js'
-
-/**
- * @subcategory Construct
- * @classdesc Common construct to use as a base for all higher level constructs.
- * @example
- * import { CommonConstruct } from '@gradientedge/cdk-utils';
- *
- * class CustomConstruct extends CommonConstruct {
- *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
- *     super(parent, id, props);
- *     this.props = props;
- *   };
- * };
- */
-export class CommonConstruct extends Construct {
-  props: CommonStackProps
-  resourceNameFormatter: ResourceNameFormatter
-  acmManager: AcmManager
-  apiManager: ApiManager
-  appConfigManager: AppConfigManager
-  codeBuildManager: CodeBuildManager
-  cloudFrontManager: CloudFrontManager
-  cloudTrailManager: CloudTrailManager
-  cloudWatchManager: CloudWatchManager
-  dynamodbManager: DynamodbManager
-  ecrManager: EcrManager
-  ecsManager: EcsManager
-  efsManager: EfsManager
-  eksManager: EksManager
-  elasticacheManager: ElastiCacheManager
-  eventManager: EventManager
-  eventTargetManager: EventTargetManager
-  evidentlyManager: EvidentlyManager
-  iamManager: IamManager
-  kmsManager: KmsManager
-  lambdaManager: LambdaManager
-  logManager: LogManager
-  route53Manager: Route53Manager
-  s3Manager: S3Manager
-  secretsManager: SecretsManager
-  sfnManager: SfnManager
-  snsManager: SnsManager
-  sqsManager: SqsManager
-  ssmManager: SsmManager
-  vpcManager: VpcManager
-  wafManager: WafManager
-
-  fullyQualifiedDomainName: string
-
-  constructor(parent: Construct, id: string, props: CommonStackProps) {
-    super(parent, id)
-    this.props = props
-    this.resourceNameFormatter = new ResourceNameFormatter(this, `${id}-rnf`, props)
-    this.acmManager = new AcmManager()
-    this.apiManager = new ApiManager()
-    this.appConfigManager = new AppConfigManager()
-    this.codeBuildManager = new CodeBuildManager()
-    this.cloudFrontManager = new CloudFrontManager()
-    this.cloudTrailManager = new CloudTrailManager()
-    this.cloudWatchManager = new CloudWatchManager()
-    this.dynamodbManager = new DynamodbManager()
-    this.ecrManager = new EcrManager()
-    this.ecsManager = new EcsManager()
-    this.efsManager = new EfsManager()
-    this.eksManager = new EksManager()
-    this.elasticacheManager = new ElastiCacheManager()
-    this.eventManager = new EventManager()
-    this.eventTargetManager = new EventTargetManager()
-    this.evidentlyManager = new EvidentlyManager()
-    this.iamManager = new IamManager()
-    this.kmsManager = new KmsManager()
-    this.lambdaManager = new LambdaManager()
-    this.logManager = new LogManager()
-    this.route53Manager = new Route53Manager()
-    this.s3Manager = new S3Manager()
-    this.secretsManager = new SecretsManager()
-    this.sfnManager = new SfnManager()
-    this.snsManager = new SnsManager()
-    this.sqsManager = new SqsManager()
-    this.ssmManager = new SsmManager()
-    this.vpcManager = new VpcManager()
-    this.wafManager = new WafManager()
-
-    this.determineFullyQualifiedDomain()
-  }
-
-  /**
-   * @summary Helper method to add CloudFormation outputs from the construct
-   * @param id scoped id of the resource
-   * @param value the value of the exported output
-   * @param description optional description for the output
-   * @param overrideId Flag which indicates whether to override the default logical id of the output
-   */
-  protected addCfnOutput(id: string, value: string, description?: string, overrideId = true): CfnOutput {
-    return createCfnOutput(id, this, value, description, overrideId)
-  }
-
-  /**
-   * @summary Determine the fully qualified domain name based on domainName & subDomain
-   */
-  protected determineFullyQualifiedDomain() {
-    this.fullyQualifiedDomainName = this.props.subDomain
-      ? `${this.props.subDomain}.${this.props.domainName}`
-      : this.props.domainName
-  }
-
-  /**
-   * @summary Utility method to determine if the initialisation is in development (dev) stage
-   * This is determined by the stage property injected via cdk context
-   */
-  public isDevelopmentStage = () => isDevStage(this.props.stage)
-
-  /**
-   * @summary Utility method to determine if the initialisation is in test (tst) stage
-   * This is determined by the stage property injected via cdk context
-   */
-  public isTestStage = () => isTestStage(this.props.stage)
-
-  /**
-   * @summary Utility method to determine if the initialisation is in uat (uat) stage
-   * This is determined by the stage property injected via cdk context
-   */
-  public isUatStage = () => isUatStage(this.props.stage)
-
-  /**
-   * @summary Utility method to determine if the initialisation is in production (prd) stage
-   * This is determined by the stage property injected via cdk context
-   */
-  public isProductionStage = () => isPrdStage(this.props.stage)
-}

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

@@ -1,4 +0,0 @@
-export * from './construct.js'
-export * from './resource-name-formatter.js'
-export * from './stack.js'
-export * from './types.js'

package/src/lib/aws/common/resource-name-formatter.ts

@@ -1,37 +0,0 @@
-import { Construct } from 'constructs'
-import { CommonStackProps, ResourceNameFormatterProps } from './types.js'
-
-export class ResourceNameFormatter extends Construct {
-  props: CommonStackProps
-
-  constructor(parent: Construct, id: string, props: CommonStackProps) {
-    super(parent, id)
-    this.props = props
-  }
-
-  /**
-   * @summary Helper method to format a resource name based on the provided options
-   * @param resourceName the resource name to format
-   * @param options options to control the formatting of the resource name
-   * @returns The formatted resource name
-   */
-  public format(resourceName: string, options?: ResourceNameFormatterProps) {
-    const elements = []
-
-    if (!options?.exclude) {
-      if (options?.globalPrefix) elements.push(this.props.globalPrefix)
-      elements.push(options?.prefix ?? this.props.resourcePrefix)
-    }
-
-    elements.push(resourceName)
-
-    if (!options?.exclude) {
-      elements.push(options?.suffix ?? this.props.resourceSuffix)
-      if (options?.globalSuffix) elements.push(this.props.globalSuffix)
-    }
-
-    elements.push(this.props.stage)
-
-    return elements.filter(Boolean).join('-')
-  }
-}

package/src/lib/aws/common/stack.ts

@@ -1,157 +0,0 @@
-import { App, Stack, StackProps } from 'aws-cdk-lib'
-import { Runtime } from 'aws-cdk-lib/aws-lambda'
-import fs from 'fs'
-import path from 'path'
-
-import { CommonConstruct } from './construct.js'
-import { CommonStackProps } from './types.js'
-
-import appRoot from 'app-root-path'
-import _ from 'lodash'
-import { isDevStage } from '../../common/index.js'
-
-/**
- * @classdesc Common stack to use as a base for all higher level constructs.
- * @example
- * import { CommonStack } from '@gradientedge/cdk-utils'
- *
- * class CustomStack extends CommonStack {
- *   constructor(parent: App, name: string, props: StackProps) {
- *     super(parent, name, props)
- *     // provision resources
- *   }
- * }
- */
-export class CommonStack extends Stack {
-  public static NODEJS_RUNTIME = Runtime.NODEJS_24_X
-
-  construct: CommonConstruct
-  props: CommonStackProps
-
-  constructor(parent: App, name: string, props: StackProps) {
-    super(parent, name, props)
-
-    /* determine extra cdk contexts */
-    this.determineExtraContexts()
-
-    /* determine extra cdk stage contexts */
-    this.determineStageContexts()
-
-    this.props = this.determineConstructProps(props)
-
-    /* initialise the construct */
-    this.construct = new CommonConstruct(this, 'cdk-utils', this.props)
-  }
-
-  /**
-   * @summary Method to determine the core CDK construct properties injected via context cdk.json
-   * @param props The stack properties
-   * @returns The stack properties
-   */
-  protected determineConstructProps(props: StackProps) {
-    return {
-      domainName: this.node.tryGetContext('domainName'),
-      excludeDomainNameForBuckets: this.node.tryGetContext('excludeDomainNameForBuckets'),
-      excludeAccountNumberForBuckets: this.node.tryGetContext('excludeAccountNumberForBuckets'),
-      extraContexts: this.node.tryGetContext('extraContexts'),
-      logRetention: this.node.tryGetContext('logRetention'),
-      name: props.stackName || 'cdk-utils',
-      nodejsRuntime: this.node.tryGetContext('nodejsRuntime') ?? CommonStack.NODEJS_RUNTIME,
-      region: this.node.tryGetContext('region'),
-      globalPrefix: this.node.tryGetContext('globalPrefix'),
-      globalSuffix: this.node.tryGetContext('globalSuffix'),
-      resourceNameOptions: this.node.tryGetContext('resourceNameOptions'),
-      resourcePrefix: this.node.tryGetContext('resourcePrefix'),
-      resourceSuffix: this.node.tryGetContext('resourceSuffix'),
-      skipStageForARecords: this.node.tryGetContext('skipStageForARecords'),
-      stackName: props.stackName,
-      stage: this.node.tryGetContext('stage'),
-      subDomain: this.node.tryGetContext('subDomain'),
-    }
-  }
-
-  /**
-   * @summary Method to determine extra cdk contexts apart from the main cdk.json
-   * - Sets the properties from the extra contexts into cdk node context
-   * - Primary use is to have layered config in separate files to enable easier maintenance and readability
-   */
-  protected determineExtraContexts() {
-    const extraContexts = this.node.tryGetContext('extraContexts')
-    const debug = this.node.tryGetContext('debug')
-
-    if (!extraContexts) {
-      if (debug) console.debug(`No additional contexts provided. Using default context properties from cdk.json`)
-      return
-    }
-
-    _.forEach(extraContexts, (context: string) => {
-      const extraContextPath = path.join(appRoot.path, context)
-
-      /* scenario where extra context is configured in cdk.json but absent in file system */
-      if (!fs.existsSync(extraContextPath)) throw `Extra context properties unavailable in path:${extraContextPath}`
-
-      /* read the extra properties */
-      const extraContextPropsBuffer = fs.readFileSync(extraContextPath)
-      if (debug) console.debug(`Adding additional contexts provided in ${extraContextPath}`)
-
-      /* parse as JSON properties */
-      const extraContextProps = JSON.parse(extraContextPropsBuffer.toString('utf-8'))
-
-      /* set each of the property into the cdk node context */
-      _.keys(extraContextProps).forEach((propKey: any) => {
-        this.node.setContext(propKey, extraContextProps[propKey])
-      })
-    })
-  }
-
-  /**
-   * @summary Method to determine extra cdk stage contexts apart from the main cdk.json
-   * - Sets the properties from the extra stage contexts into cdk node context
-   * - Primary use is to have layered config for each environment which is injected into the context
-   */
-  protected determineStageContexts() {
-    const stage = this.node.tryGetContext('stage')
-    const stageContextPath = this.node.tryGetContext('stageContextPath') || 'cdkEnv'
-    const stageContextFilePath = path.join(appRoot.path, stageContextPath, `${stage}.json`)
-
-    const debug = this.node.tryGetContext('debug')
-
-    if (isDevStage(stage)) {
-      if (debug) console.debug(`Development stage. Using default stage context properties`)
-    }
-
-    /* alert default context usage when extra stage config is missing */
-    if (!fs.existsSync(stageContextFilePath)) {
-      if (debug) console.debug(`Stage specific context properties unavailable in path:${stageContextFilePath}`)
-      if (debug) console.debug(`Using default stage context properties for ${stage} stage`)
-      return
-    }
-
-    /* read the extra properties */
-    const stageContextPropsBuffer = fs.readFileSync(stageContextFilePath)
-    if (debug) console.debug(`Adding additional stage contexts provided in ${stageContextFilePath}`)
-
-    /* parse as JSON properties */
-    const stageContextProps = JSON.parse(stageContextPropsBuffer.toString('utf-8'))
-
-    /* set each of the property into the cdk node context */
-    _.keys(stageContextProps).forEach((propKey: any) => {
-      /* handle object, array properties */
-      if (typeof stageContextProps[propKey] === 'object' && !Array.isArray(stageContextProps[propKey])) {
-        this.node.setContext(propKey, _.merge(this.node.tryGetContext(propKey), stageContextProps[propKey]))
-      } else {
-        /* handle all other primitive properties */
-        this.node.setContext(propKey, stageContextProps[propKey])
-      }
-    })
-  }
-
-  /**
-   * @summary Determine the fully qualified domain name based on domainName & subDomain
-   */
-  protected fullyQualifiedDomain() {
-    const domainName = this.node.tryGetContext('domainName')
-    const subDomain = this.node.tryGetContext('subDomain')
-    return subDomain ? `${subDomain}.${domainName}` : domainName
-  }
-}

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

@@ -1,30 +0,0 @@
-import { StackProps } from 'aws-cdk-lib'
-import { Runtime, Tracing } from 'aws-cdk-lib/aws-lambda'
-import { RetentionDays } from 'aws-cdk-lib/aws-logs'
-import { BaseProps } from '../../common/index.js'
-
-/**
- */
-export interface CommonStackProps extends BaseProps, StackProps {
-  region: string
-  resourceProjectIdentifier?: string
-  globalPrefix?: string
-  globalSuffix?: string
-  resourcePrefix?: string
-  resourceSuffix?: string
-  logRetention?: RetentionDays
-  defaultReservedLambdaConcurrentExecutions?: number
-  defaultTracing?: Tracing
-  excludeDomainNameForBuckets?: boolean
-  excludeAccountNumberForBuckets?: boolean
-  nodejsRuntime?: Runtime
-  resourceNameOptions?: { [key: string]: ResourceNameFormatterProps }
-}
-
-export interface ResourceNameFormatterProps {
-  exclude?: boolean
-  globalPrefix?: boolean
-  globalSuffix?: boolean
-  prefix?: string
-  suffix?: string
-}

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

@@ -1,3 +0,0 @@
-export * from './main.js'
-export * from './target.js'
-export * from './types.js'

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

@@ -1,235 +0,0 @@
-import { Fn, RemovalPolicy } from 'aws-cdk-lib'
-import {
-  AccessLogFormat,
-  BasePathMapping,
-  Cors,
-  EndpointType,
-  LogGroupLogDestination,
-  MethodLoggingLevel,
-  Resource,
-  RestApi,
-} from 'aws-cdk-lib/aws-apigateway'
-import { ISecret } from 'aws-cdk-lib/aws-secretsmanager'
-import { Construct } from 'constructs'
-import { CommonConstruct } from '../../common/index.js'
-import { ApiToAnyTargetRestApi } from './target.js'
-import { ApiToAnyTargetProps, ApiToAnyTargetRestApiResource, ApiToAnyTargetRestApiType } from './types.js'
-
-/**
- * @classdesc Provides a construct to create and deploy a shallow API Gateway
- * @example
- * import { ApiToAnyTarget, ApiToAnyTargetProps } '@gradientedge/cdk-utils'
- * import { Construct } from 'constructs'
- *
- * class CustomConstruct extends ApiToAnyTarget {
- *   constructor(parent: Construct, id: string, props: ApiToAnyTargetProps) {
- *     super(parent, id, props)
- *     this.props = props
- *     this.id = id
- *     this.initResources()
- *   }
- * }
- */
-export class ApiToAnyTarget extends CommonConstruct {
-  props: ApiToAnyTargetProps
-  id: string
-
-  /* application related resources */
-  applicationSecrets: ISecret[]
-
-  /* rest restApi related resources */
-  apiToAnyTargetRestApi: ApiToAnyTargetRestApiType
-  apiResource: string
-
-  constructor(parent: Construct, id: string, props: ApiToAnyTargetProps) {
-    super(parent, id, props)
-    this.props = props
-    this.id = id
-
-    this.apiToAnyTargetRestApi = new ApiToAnyTargetRestApi()
-  }
-
-  public initResources() {
-    /* application related resources */
-    this.resolveSecrets()
-
-    /* core resources */
-    this.resolveHostedZone()
-    this.resolveCertificate()
-
-    /* restApi related resources */
-    this.createApiToAnyTargetRestApi()
-    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.apiToAnyTargetRestApi.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.apiToAnyTargetRestApi.certificate = this.acmManager.resolveCertificate(
-      `${this.id}-certificate`,
-      this,
-      this.props.api.certificate
-    )
-  }
-
-  protected createApiToAnyTargetRestApi() {
-    if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
-      this.apiToAnyTargetRestApi.api = RestApi.fromRestApiId(
-        this,
-        `${this.id}-rest-api`,
-        Fn.importValue(this.props.api.importedRestApiRef)
-      )
-      return
-    }
-
-    if (!this.props.api.restApi?.restApiName) throw `RestApi name undefined for ${this.id}`
-
-    const restApiName = this.resourceNameFormatter.format(
-      this.props.api.restApi?.restApiName,
-      this.props.resourceNameOptions?.apigateway
-    )
-
-    const restApiAccessLogName = this.resourceNameFormatter.format(
-      `${this.props.api.restApi?.restApiName}-access`,
-      this.props.resourceNameOptions?.apigateway
-    )
-
-    this.apiToAnyTargetRestApi.accessLogGroup = this.logManager.createLogGroup(`${this.id}-rest-api-access-log`, this, {
-      logGroupName: restApiAccessLogName,
-      removalPolicy: RemovalPolicy.DESTROY,
-    })
-
-    this.apiToAnyTargetRestApi.api = new RestApi(this, `${this.id}-rest-api`, {
-      cloudWatchRole: this.props.api.restApi?.cloudWatchRole ?? true,
-      defaultCorsPreflightOptions: {
-        allowHeaders: Cors.DEFAULT_HEADERS,
-        allowMethods: Cors.ALL_METHODS,
-        allowOrigins: Cors.ALL_ORIGINS,
-      },
-      defaultIntegration: this.apiToAnyTargetRestApi.integration,
-      defaultMethodOptions: {
-        methodResponses: [this.apiToAnyTargetRestApi.methodResponse, this.apiToAnyTargetRestApi.methodErrorResponse],
-      },
-      deploy: this.props.api.restApi?.deploy ?? true,
-      deployOptions: {
-        accessLogDestination: new LogGroupLogDestination(this.apiToAnyTargetRestApi.accessLogGroup),
-        accessLogFormat: AccessLogFormat.jsonWithStandardFields(),
-        dataTraceEnabled: this.props.api.restApi?.deployOptions?.dataTraceEnabled,
-        description: `${this.id} - ${this.props.stage} stage`,
-        loggingLevel: MethodLoggingLevel.INFO,
-        metricsEnabled: true,
-        stageName: this.props.stage,
-        tracingEnabled: this.props.api.restApi?.deployOptions?.tracingEnabled,
-      },
-      endpointConfiguration: {
-        types: [this.isProductionStage() ? EndpointType.EDGE : EndpointType.REGIONAL],
-      },
-      ...this.props.api.restApi,
-      restApiName,
-    })
-    this.addCfnOutput(`${this.id}-restApiId`, this.apiToAnyTargetRestApi.api.restApiId)
-    this.addCfnOutput(`${this.id}-restApiRootResourceId`, this.apiToAnyTargetRestApi.api.root.resourceId)
-  }
-
-  protected createApiToAnyTargetResource(apiResourceProps: ApiToAnyTargetRestApiResource) {
-    if (!this.props.api.withResource) return
-    let rootResource
-    if (this.props.api.withResource && this.props.api.importedRestApiRootResourceRef) {
-      rootResource = Resource.fromResourceAttributes(this, `${this.id}-root-resource-for-${apiResourceProps.path}`, {
-        path: '/',
-        resourceId: Fn.importValue(this.props.api.importedRestApiRootResourceRef),
-        restApi: this.apiToAnyTargetRestApi.api,
-      })
-    } else {
-      rootResource = this.apiToAnyTargetRestApi.api.root
-    }
-
-    return this.apiManager.createApiResource(
-      `${this.id}-resource-${apiResourceProps.path}}`,
-      this,
-      apiResourceProps.parent ?? rootResource,
-      apiResourceProps.path,
-      apiResourceProps.integration,
-      apiResourceProps.addProxy,
-      apiResourceProps.authorizer,
-      apiResourceProps.allowedOrigins,
-      apiResourceProps.allowedMethods,
-      apiResourceProps.allowedHeaders,
-      apiResourceProps.methodRequestParameters,
-      apiResourceProps.proxyIntegration,
-      apiResourceProps.enableDefaultCors,
-      apiResourceProps.mockIntegration,
-      apiResourceProps.mockMethodResponses
-    )
-  }
-
-  protected createApiDomain() {
-    if (this.props.api.useExisting) return
-    this.apiToAnyTargetRestApi.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.apiToAnyTargetRestApi.certificate
-    )
-  }
-
-  protected createApiBasePathMapping() {
-    if (this.props.api.useExisting) return
-    new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
-      basePath: '',
-      domainName: this.apiToAnyTargetRestApi.domain,
-      restApi: this.apiToAnyTargetRestApi.api,
-      stage: this.apiToAnyTargetRestApi.api.deploymentStage,
-    })
-  }
-
-  protected createApiRouteAssets() {
-    if (this.props.api.useExisting) return
-    this.route53Manager.createApiGatewayARecord(
-      `${this.id}-custom-domain-a-record`,
-      this,
-      this.props.apiSubDomain,
-      this.apiToAnyTargetRestApi.domain,
-      this.apiToAnyTargetRestApi.hostedZone,
-      this.props.skipStageForARecords
-    )
-  }
-}

package/src/lib/aws/construct/api-to-any-target/target.ts

@@ -1,29 +0,0 @@
-import {
-  IRestApi,
-  IAuthorizer,
-  BasePathMapping,
-  DomainName,
-  Integration,
-  Method,
-  MethodResponse,
-  Resource,
-} from 'aws-cdk-lib/aws-apigateway'
-import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager'
-import { LogGroup } from 'aws-cdk-lib/aws-logs'
-import { IHostedZone } from 'aws-cdk-lib/aws-route53'
-import { ApiToAnyTargetRestApiType } from './types.js'
-
-export class ApiToAnyTargetRestApi implements ApiToAnyTargetRestApiType {
-  accessLogGroup: LogGroup
-  api: IRestApi
-  authoriser?: IAuthorizer
-  basePathMappings: BasePathMapping[]
-  certificate: ICertificate
-  domain: DomainName
-  hostedZone: IHostedZone
-  integration: Integration
-  method: { [httpMethod: string]: Method }
-  methodErrorResponse: MethodResponse
-  methodResponse: MethodResponse
-  resource: { [path: string]: Resource }
-}