@gradientedge/cdk-utils 10.8.0 → 11.0.0

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

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

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

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

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

@@ -1,284 +0,0 @@
-import { Fn } from 'aws-cdk-lib'
-import { BasePathMapping, LambdaIntegration, Resource, RestApi } from 'aws-cdk-lib/aws-apigateway'
-import { PolicyDocument, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam'
-import { Function } from 'aws-cdk-lib/aws-lambda'
-import { ISecret } from 'aws-cdk-lib/aws-secretsmanager'
-import { Construct } from 'constructs'
-import { CommonConstruct } from '../../common/index.js'
-import { ApiToLambdaTargetRestApi } from './api.js'
-import { ApiToLambdaTargetProps, ApiToLambdaTargetRestApiType } from './types.js'
-
-/**
- */
-export class ApiToLambdaTarget extends CommonConstruct {
-  props: ApiToLambdaTargetProps
-  id: string
-
-  /* application related resources */
-  applicationSecrets: ISecret[]
-
-  /* rest restApi related resources */
-  apiToLambdaTargetRestApi: ApiToLambdaTargetRestApiType
-  apiResource: string
-
-  constructor(parent: Construct, id: string, props: ApiToLambdaTargetProps) {
-    super(parent, id, props)
-
-    this.props = props
-    this.id = id
-
-    this.apiToLambdaTargetRestApi = new ApiToLambdaTargetRestApi()
-  }
-
-  public initResources() {
-    this.resolveSecrets()
-    this.resolveHostedZone()
-    this.resolveCertificate()
-    this.createApiToLambdaTargetMethodResponse()
-    this.createApiToLambdaTargetMethodErrorResponse()
-    this.resolveApiToLambdaTargetFunction()
-    this.createApiToLambdaTargetRestApi()
-    this.createApiToLambdaTargetResource()
-    this.createApiToLambdaTargetPolicy()
-    this.createApiToLambdaTargetRole()
-    this.createApiToLambdaTargetIntegration()
-    this.createApiToLambdaTargetResourceMethod()
-    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 api integration method response
-   */
-  protected createApiToLambdaTargetMethodResponse() {
-    if (!this.props.api.withResource) return
-    this.apiToLambdaTargetRestApi.methodResponse = {
-      ...{
-        responseParameters: {
-          'method.response.header.Access-Control-Allow-Credentials': true,
-          'method.response.header.Access-Control-Allow-Origin': true,
-          'method.response.header.Content-Type': true,
-        },
-        statusCode: '200',
-      },
-      ...this.props.api.methodResponse,
-    }
-  }
-
-  /**
-   * @summary Method to create api integration method error response
-   */
-  protected createApiToLambdaTargetMethodErrorResponse() {
-    if (!this.props.api.withResource) return
-    this.apiToLambdaTargetRestApi.methodErrorResponse = {
-      ...{
-        responseParameters: {
-          'method.response.header.Access-Control-Allow-Credentials': true,
-          'method.response.header.Access-Control-Allow-Origin': true,
-          'method.response.header.Content-Type': true,
-        },
-        statusCode: '400',
-      },
-      ...this.props.api.methodErrorResponse,
-    }
-  }
-
-  protected resolveApiToLambdaTargetFunction() {
-    this.apiToLambdaTargetRestApi.lambda = Function.fromFunctionName(
-      this,
-      `${this.id}-lambda`,
-      this.resourceNameFormatter.format(this.props.lambdaFunctionName)
-    )
-  }
-
-  /**
-   * @summary Method to create rest restApi for Api
-   */
-  protected createApiToLambdaTargetRestApi() {
-    if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
-      this.apiToLambdaTargetRestApi.api = RestApi.fromRestApiId(
-        this,
-        `${this.id}-rest-api`,
-        Fn.importValue(this.props.api.importedRestApiRef)
-      )
-      return
-    }
-
-    this.props.api.restApi = {
-      ...this.props.api.restApi,
-      defaultMethodOptions: {
-        methodResponses: [
-          this.apiToLambdaTargetRestApi.methodResponse,
-          this.apiToLambdaTargetRestApi.methodErrorResponse,
-        ],
-      },
-    }
-
-    this.apiToLambdaTargetRestApi.api = this.apiManager.createLambdaRestApi(
-      `${this.id}-lambda-rest-api`,
-      this,
-      this.props.api.restApi,
-      this.apiToLambdaTargetRestApi.lambda
-    )
-
-    this.addCfnOutput(`${this.id}-restApiId`, this.apiToLambdaTargetRestApi.api.restApiId)
-    this.addCfnOutput(`${this.id}-restApiRootResourceId`, this.apiToLambdaTargetRestApi.api.root.resourceId)
-  }
-
-  /**
-   * @summary Method to create api integration resource
-   */
-  protected createApiToLambdaTargetResource() {
-    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`, {
-        path: '/',
-        resourceId: Fn.importValue(this.props.api.importedRestApiRootResourceRef),
-        restApi: this.apiToLambdaTargetRestApi.api,
-      })
-    } else {
-      rootResource = this.apiToLambdaTargetRestApi.api.root
-    }
-
-    this.apiToLambdaTargetRestApi.resource = rootResource.addResource(this.props.api.resource ?? this.apiResource)
-  }
-
-  protected createApiToLambdaTargetPolicy() {
-    this.apiToLambdaTargetRestApi.policy = new PolicyDocument({
-      statements: [
-        this.iamManager.statementForPutEvents(),
-        this.iamManager.statementForInvokeLambda([this.apiToLambdaTargetRestApi.lambda.functionArn]),
-      ],
-    })
-  }
-
-  /**
-   * @summary Method to create a role for api integration
-   */
-  protected createApiToLambdaTargetRole() {
-    if (!this.apiToLambdaTargetRestApi.policy) throw 'Policy undefined'
-
-    this.apiToLambdaTargetRestApi.role = new Role(this, `${this.id}-rest-api-role`, {
-      assumedBy: new ServicePrincipal('apigateway.amazonaws.com'),
-      inlinePolicies: { policy: this.apiToLambdaTargetRestApi.policy },
-    })
-  }
-
-  /**
-   * @summary Method to create api integration resource method
-   */
-  protected createApiToLambdaTargetIntegration() {
-    this.apiToLambdaTargetRestApi.integration = new LambdaIntegration(this.apiToLambdaTargetRestApi.lambda, {
-      allowTestInvoke: true,
-      credentialsRole: this.apiToLambdaTargetRestApi.role,
-    })
-  }
-
-  /**
-   * @summary Method to create api integration resource method
-   */
-  protected createApiToLambdaTargetResourceMethod() {
-    if (!this.props.api.withResource) return
-    this.apiToLambdaTargetRestApi.method = this.apiToLambdaTargetRestApi.resource.addMethod(
-      'POST',
-      this.apiToLambdaTargetRestApi.integration,
-      {
-        authorizer: this.apiToLambdaTargetRestApi.authoriser,
-        methodResponses: [
-          this.apiToLambdaTargetRestApi.methodResponse,
-          this.apiToLambdaTargetRestApi.methodErrorResponse,
-        ],
-      }
-    )
-  }
-
-  /**
-   * @summary Method to create custom restApi domain for 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 Api
-   */
-  protected createApiBasePathMapping() {
-    if (this.props.api.useExisting) return
-    new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
-      basePath: '',
-      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
-    )
-  }
-}

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

@@ -1,72 +0,0 @@
-import { CommonStackProps } from '../../common/index.js'
-import {
-  BasePathMapping,
-  DomainName,
-  IAuthorizer,
-  Integration,
-  IntegrationResponse,
-  IRestApi,
-  Method,
-  MethodResponse,
-  Model,
-  Resource,
-} from 'aws-cdk-lib/aws-apigateway'
-import { AcmProps, LambdaRestApiProps } from '../../services/index.js'
-import * as acm from 'aws-cdk-lib/aws-certificatemanager'
-import * as route53 from 'aws-cdk-lib/aws-route53'
-import { IFunction } from 'aws-cdk-lib/aws-lambda'
-import { ITopic } from 'aws-cdk-lib/aws-sns'
-import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam'
-
-/**
- */
-export interface ApiToLambdaTargetRestApiType {
-  api: IRestApi
-  authoriser?: IAuthorizer
-  basePathMappings: BasePathMapping[]
-  certificate: acm.ICertificate
-  domain: DomainName
-  errorResponseModel: Model
-  hostedZone: route53.IHostedZone
-  integration: Integration
-  integrationErrorResponse: IntegrationResponse
-  integrationRequestParameters: { [p: string]: string }
-  integrationRequestTemplates: { [p: string]: string }
-  integrationResponse: IntegrationResponse
-  lambda: IFunction
-  method: Method
-  methodErrorResponse: MethodResponse
-  methodResponse: MethodResponse
-  policy?: PolicyDocument
-  resource: Resource
-  responseModel: Model
-  role?: Role
-  topic?: ITopic
-}
-
-/**
- */
-export interface ApiToLambdaTargetRestApiProps {
-  certificate: AcmProps
-  importedRestApiRef?: string
-  importedRestApiRootResourceRef?: string
-  methodErrorResponse: MethodResponse
-  methodResponse: MethodResponse
-  resource: string
-  restApi: LambdaRestApiProps
-  useExisting: boolean
-  withResource?: boolean
-}
-
-/**
- */
-export interface ApiToLambdaTargetProps extends CommonStackProps {
-  api: ApiToLambdaTargetRestApiProps
-  apiRootPaths?: string[]
-  apiSubDomain: string
-  lambdaFunctionName: string
-  logLevel: string
-  nodeEnv: string
-  timezone: string
-  useExistingHostedZone: boolean
-}

package/src/lib/aws/construct/application-configuration/index.ts

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

package/src/lib/aws/construct/application-configuration/main.ts

@@ -1,125 +0,0 @@
-import { Duration, Fn } from 'aws-cdk-lib'
-import {
-  CfnApplication,
-  CfnConfigurationProfile,
-  CfnDeployment,
-  CfnEnvironment,
-  CfnHostedConfigurationVersion,
-  DeploymentStrategy,
-  IDeploymentStrategy,
-  RolloutStrategy,
-} from 'aws-cdk-lib/aws-appconfig'
-import { Construct } from 'constructs'
-import { CommonConstruct } from '../../common/index.js'
-import { ApplicationConfigurationProps } from './types.js'
-
-export class ApplicationConfiguration extends CommonConstruct {
-  declare props: ApplicationConfigurationProps
-  id: string
-  appConfigApplication: CfnApplication
-  appConfigEnvironment: CfnEnvironment
-  appConfigProfile: CfnConfigurationProfile
-  appConfigVersion: CfnHostedConfigurationVersion
-  appConfigDeploymentStrategy: IDeploymentStrategy
-
-  constructor(parent: Construct, id: string, props: ApplicationConfigurationProps) {
-    super(parent, id, props)
-    this.props = props
-    this.id = id
-  }
-
-  public initResources() {
-    this.createConfiguration()
-    this.resolveEnvironmentVariables()
-  }
-
-  protected createConfiguration() {
-    this.createAppConfigApplication()
-    this.createAppConfigEnvironment()
-    this.createAppConfigProfile()
-    this.createAppConfigVersion()
-    this.createAppConfigDeploymentStrategy()
-    this.createAppConfigDeployment()
-  }
-
-  protected createAppConfigApplication() {
-    this.appConfigApplication = this.appConfigManager.createApplication(
-      `${this.id}-ac-application`,
-      this,
-      this.props.appConfig
-    )
-  }
-
-  protected createAppConfigEnvironment() {
-    this.appConfigEnvironment = this.appConfigManager.createEnvironment(
-      `${this.id}-ac-environment`,
-      this,
-      Fn.ref(this.appConfigApplication.logicalId),
-      this.props.appConfig
-    )
-  }
-
-  protected createAppConfigProfile() {
-    this.appConfigProfile = this.appConfigManager.createConfigurationProfile(
-      `${this.id}-ac-profile`,
-      this,
-      Fn.ref(this.appConfigApplication.logicalId),
-      this.props.appConfig
-    )
-  }
-
-  protected createAppConfigVersion() {
-    this.appConfigVersion = new CfnHostedConfigurationVersion(this, `${this.id}-ac-configuration`, {
-      applicationId: Fn.ref(this.appConfigApplication.logicalId),
-      configurationProfileId: Fn.ref(this.appConfigProfile.logicalId),
-      content: JSON.stringify(this.props.appConfigContent),
-      contentType: 'application/json',
-    })
-  }
-
-  protected createAppConfigDeploymentStrategy() {
-    if (!this.props.appConfig.deploymentStrategy) return
-
-    if (this.props.appConfig.deploymentStrategy?.deploymentStrategyArn) {
-      this.appConfigDeploymentStrategy = DeploymentStrategy.fromDeploymentStrategyArn(
-        this,
-        `${this.id}-ac-deployment-strategy`,
-        this.props.appConfig.deploymentStrategy?.deploymentStrategyArn
-      )
-      return
-    }
-
-    this.appConfigDeploymentStrategy = new DeploymentStrategy(this, `${this.id}-ac-deployment-strategy`, {
-      ...this.props.appConfig.deploymentStrategy,
-      rolloutStrategy:
-        this.props.appConfig.deploymentStrategy?.rolloutStrategy ??
-        RolloutStrategy.linear({
-          growthFactor: 100,
-          deploymentDuration: Duration.minutes(0),
-          finalBakeTime: Duration.minutes(0),
-        }),
-      deploymentStrategyName: this.resourceNameFormatter.format(
-        this.props.appConfig.deploymentStrategy.deploymentStrategyName ?? 'common-deployment-strategy',
-        this.props.resourceNameOptions?.appconfig
-      ),
-    })
-  }
-
-  protected createAppConfigDeployment() {
-    new CfnDeployment(this, `${this.id}-app-config-deployment`, {
-      applicationId: Fn.ref(this.appConfigApplication.logicalId),
-      configurationProfileId: Fn.ref(this.appConfigProfile.logicalId),
-      configurationVersion: Fn.ref(this.appConfigVersion.logicalId),
-      deploymentStrategyId: this.appConfigDeploymentStrategy.deploymentStrategyId,
-      environmentId: Fn.ref(this.appConfigEnvironment.logicalId),
-    })
-  }
-
-  public resolveEnvironmentVariables(): any {
-    return {
-      APP_CONFIG_APPLICATION_ID: Fn.ref(this.appConfigApplication.logicalId),
-      APP_CONFIG_CONFIGURATION_PROFILE_ID: Fn.ref(this.appConfigProfile.logicalId),
-      APP_CONFIG_ENVIRONMENT_ID: Fn.ref(this.appConfigEnvironment.logicalId),
-    }
-  }
-}

package/src/lib/aws/construct/application-configuration/types.ts

@@ -1,7 +0,0 @@
-import { CommonStackProps } from '../../common/index.js'
-import { AppConfigProps } from '../../services/index.js'
-
-export interface ApplicationConfigurationProps extends CommonStackProps {
-  appConfig: AppConfigProps
-  appConfigContent: any
-}

package/src/lib/aws/construct/event-handler/handler.ts

@@ -1,30 +0,0 @@
-import { Archive, IEventBus, IRuleTarget, Rule } from 'aws-cdk-lib/aws-events'
-import { CloudWatchLogGroup, EcsTask, LambdaFunction, SfnStateMachine, SqsQueue } from 'aws-cdk-lib/aws-events-targets'
-import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam'
-import { IFunction } from 'aws-cdk-lib/aws-lambda'
-import { LogGroup } from 'aws-cdk-lib/aws-logs'
-import { Queue } from 'aws-cdk-lib/aws-sqs'
-import { Chain, Map, StateMachine } from 'aws-cdk-lib/aws-stepfunctions'
-import { EventHandlerType } from './types.js'
-
-export class Handler implements EventHandlerType {
-  archive: Archive
-  ecsTargets: EcsTask[] = []
-  eventBus: IEventBus
-  eventWorkflowDefinition: Chain
-  lambdaFunctions: IFunction[] = []
-  lambdaTargets: LambdaFunction[] = []
-  logTargets: CloudWatchLogGroup[] = []
-  queue: Queue
-  rule: Rule
-  rulePattern: any
-  sqsTargets: SqsQueue[] = []
-  stepFunctionTargets: SfnStateMachine[] = []
-  targets: IRuleTarget[] = []
-  workflow: StateMachine
-  workflowDefinition: Chain
-  workflowLogGroup: LogGroup
-  workflowMapState: Map
-  workflowPolicy: PolicyDocument
-  workflowRole: Role
-}

package/src/lib/aws/construct/event-handler/index.ts

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