@gradientedge/cdk-utils-aws 1.0.0

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

@@ -0,0 +1,154 @@
+import { Fn, RemovalPolicy } from 'aws-cdk-lib';
+import { AccessLogFormat, BasePathMapping, Cors, EndpointType, LogGroupLogDestination, MethodLoggingLevel, Resource, RestApi, } from 'aws-cdk-lib/aws-apigateway';
+import { CommonConstruct } from '../../common/index.js';
+import { ApiToAnyTargetRestApi } from './target.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;
+    id;
+    /* application related resources */
+    applicationSecrets;
+    /* rest restApi related resources */
+    apiToAnyTargetRestApi;
+    apiResource;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+        this.apiToAnyTargetRestApi = new ApiToAnyTargetRestApi();
+    }
+    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
+     */
+    resolveSecrets() {
+        this.applicationSecrets = [];
+    }
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    resolveHostedZone() {
+        this.apiToAnyTargetRestApi.hostedZone = this.route53Manager.withHostedZoneFromFullyQualifiedDomainName(`${this.id}-hosted-zone`, this, this.props.useExistingHostedZone);
+    }
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    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);
+    }
+    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);
+    }
+    createApiToAnyTargetResource(apiResourceProps) {
+        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);
+    }
+    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);
+    }
+    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,
+        });
+    }
+    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/dist/src/construct/api-to-any-target/target.d.ts

@@ -0,0 +1,23 @@
+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 declare 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;
+    };
+}

package/dist/src/construct/api-to-any-target/target.js

@@ -0,0 +1,14 @@
+export class ApiToAnyTargetRestApi {
+    accessLogGroup;
+    api;
+    authoriser;
+    basePathMappings;
+    certificate;
+    domain;
+    hostedZone;
+    integration;
+    method;
+    methodErrorResponse;
+    methodResponse;
+    resource;
+}

package/dist/src/construct/api-to-any-target/types.d.ts

@@ -0,0 +1,60 @@
+import { BasePathMapping, DomainName, IAuthorizer, IResource, IRestApi, Integration, Method, MethodResponse, MockIntegration, 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 { CommonStackProps } from '../../common/index.js';
+import { AcmProps, RestApigProps } from '../../services/index.js';
+export interface 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;
+    };
+}
+export interface ApiToAnyTargetRestApiResource {
+    addProxy: boolean;
+    authorizer?: IAuthorizer;
+    allowedOrigins?: string[];
+    allowedMethods?: string[];
+    allowedHeaders?: string[];
+    integration: Integration;
+    methodRequestParameters?: {
+        [param: string]: boolean;
+    };
+    path: string;
+    parent?: IResource;
+    proxyIntegration?: Integration;
+    enableDefaultCors?: boolean;
+    mockIntegration?: MockIntegration;
+    mockMethodResponses?: MethodResponse[];
+}
+export interface ApiToAnyTargetRestApiProps {
+    certificate: AcmProps;
+    importedRestApiRef?: string;
+    importedRestApiRootResourceRef?: string;
+    methodErrorResponse: MethodResponse;
+    methodResponse: MethodResponse;
+    restApi: RestApigProps;
+    useExisting: boolean;
+    withResource?: boolean;
+}
+export interface ApiToAnyTargetProps extends CommonStackProps {
+    api: ApiToAnyTargetRestApiProps;
+    apiRootPaths?: string[];
+    apiSubDomain: string;
+    logLevel: string;
+    nodeEnv: string;
+    timezone: string;
+    useExistingHostedZone: boolean;
+}

package/dist/src/construct/api-to-any-target/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/construct/api-to-eventbridge-target/api.d.ts

@@ -0,0 +1,34 @@
+import { 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 { LogGroup } from 'aws-cdk-lib/aws-logs';
+import { IHostedZone } from 'aws-cdk-lib/aws-route53';
+import { Topic } from 'aws-cdk-lib/aws-sns';
+import { ApiToEventBridgeTargetRestApiType } from './types.js';
+/**
+ * @classdesc Provides a construct to contain api resources for ApiToEventBridgeTargetWithSns
+ */
+export declare class ApiToEventbridgeTargetRestApi implements ApiToEventBridgeTargetRestApiType {
+    accessLogGroup: LogGroup;
+    api: RestApi;
+    certificate: ICertificate;
+    domain: DomainName;
+    errorResponseModel: Model;
+    hostedZone: IHostedZone;
+    integration: Integration;
+    integrationErrorResponse: IntegrationResponse;
+    integrationRequestParameters: {
+        [p: string]: string;
+    };
+    integrationRequestTemplates: {
+        [p: string]: string;
+    };
+    integrationResponse: IntegrationResponse;
+    method: Method;
+    methodErrorResponse: MethodResponse;
+    methodResponse: MethodResponse;
+    resource: Resource;
+    responseModel: Model;
+    topic: Topic;
+    role: Role;
+}

package/dist/src/construct/api-to-eventbridge-target/api.js

@@ -0,0 +1,23 @@
+/**
+ * @classdesc Provides a construct to contain api resources for ApiToEventBridgeTargetWithSns
+ */
+export class ApiToEventbridgeTargetRestApi {
+    accessLogGroup;
+    api;
+    certificate;
+    domain;
+    errorResponseModel;
+    hostedZone;
+    integration;
+    integrationErrorResponse;
+    integrationRequestParameters;
+    integrationRequestTemplates;
+    integrationResponse;
+    method;
+    methodErrorResponse;
+    methodResponse;
+    resource;
+    responseModel;
+    topic;
+    role;
+}

package/dist/src/construct/api-to-eventbridge-target/event.d.ts

@@ -0,0 +1,15 @@
+import { IEventBus, Rule } from 'aws-cdk-lib/aws-events';
+import { LogGroup } from 'aws-cdk-lib/aws-logs';
+import { ApiToEventBridgeTargetEventType } from './types.js';
+/**
+ * @classdesc Provides a construct to contain event resources for ApiToEventBridgeTargetWithSns
+ */
+export declare class ApiToEventbridgeTargetEvent implements ApiToEventBridgeTargetEventType {
+    eventBus: IEventBus;
+    logGroup: LogGroup;
+    logGroupFailure: LogGroup;
+    logGroupSuccess: LogGroup;
+    rule: Rule;
+    ruleFailure: Rule;
+    ruleSuccess: Rule;
+}

package/dist/src/construct/api-to-eventbridge-target/event.js

@@ -0,0 +1,12 @@
+/**
+ * @classdesc Provides a construct to contain event resources for ApiToEventBridgeTargetWithSns
+ */
+export class ApiToEventbridgeTargetEvent {
+    eventBus;
+    logGroup;
+    logGroupFailure;
+    logGroupSuccess;
+    rule;
+    ruleFailure;
+    ruleSuccess;
+}

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

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

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

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

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

@@ -0,0 +1,121 @@
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { ApiToEventBridgeTargetEventType, ApiToEventBridgeTargetProps, ApiToEventBridgeTargetRestApiType } from './types.js';
+/**
+ * @classdesc Provides a construct to create and deploy API Gateway invocations to EventBridge
+ *
+ * <b>Architecture</b><br/> ![Architecture](./ApiToEventBridgeTarget.jpg)
+ * @example
+ * import { ApiToEventBridgeTarget, ApiToEventBridgeTargetProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends ApiToEventBridgeTarget {
+ *   constructor(parent: Construct, id: string, props: ApiToEventBridgeTargetProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare class ApiToEventBridgeTarget extends CommonConstruct {
+    props: ApiToEventBridgeTargetProps;
+    id: string;
+    applicationSecrets: ISecret[];
+    apiEvent: ApiToEventBridgeTargetEventType;
+    apiToEventBridgeTargetRestApi: ApiToEventBridgeTargetRestApiType;
+    apiResource: string;
+    constructor(parent: Construct, id: string, props: ApiToEventBridgeTargetProps);
+    initResources(): void;
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    protected resolveSecrets(): void;
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    protected resolveHostedZone(): void;
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    protected resolveCertificate(): void;
+    /**
+     * @summary Method to create or use an existing event bus for api payload deliveries
+     */
+    protected createApiToEventBridgeTargetEventBus(): void;
+    /**
+     * @summary Method to create a log group for successful api payload deliveries
+     */
+    protected createApiToEventBridgeTargetLogGroup(): void;
+    /**
+     * Method to create EventBridge rule with lambda target for success
+     */
+    protected createApiToEventBridgeTargetRule(): void;
+    protected createApiToEventBridgeTargetPolicy(): void;
+    /**
+     * @summary Method to create a role for api integration
+     */
+    protected createApiToEventBridgeTargetRole(): void;
+    /**
+     * @summary Method to create api integration request parameters
+     */
+    protected createApiToEventBridgeTargetIntegrationRequestParameters(): void;
+    /**
+     * @summary Method to create api integration request templates
+     */
+    protected createApiToEventBridgeTargetIntegrationRequestTemplates(): void;
+    /**
+     * @summary Method to create api integration response
+     */
+    protected createApiToEventBridgeTargetIntegrationResponse(): void;
+    /**
+     * @summary Method to create api integration error response
+     */
+    protected createApiToEventBridgeTargetIntegrationErrorResponse(): void;
+    /**
+     * @summary Method to create api integration
+     */
+    protected createApiToEventBridgeTargetIntegration(): void;
+    /**
+     * @summary Method to create api integration method response
+     */
+    protected createApiToEventBridgeTargetMethodResponse(): void;
+    /**
+     * @summary Method to create api integration method error response
+     */
+    protected createApiToEventBridgeTargetMethodErrorResponse(): void;
+    /**
+     * @summary Method to create rest restApi for Api
+     */
+    protected createApiToEventBridgeTargetRestApi(): void;
+    /**
+     * @summary Method to create api integration response model
+     */
+    protected createApiToEventBridgeTargetResponseModel(): void;
+    /**
+     * @summary Method to create api integration error response model
+     */
+    protected createApiToEventBridgeTargetErrorResponseModel(): void;
+    /**
+     * @summary Method to create api integration resource
+     */
+    protected createApiToEventBridgeTargetResource(): void;
+    /**
+     * @summary Method to create api integration resource method
+     */
+    protected createApiToEventBridgeTargetResourceMethod(): void;
+    /**
+     * @summary Method to create custom restApi domain for Api
+     */
+    protected createApiDomain(): void;
+    /**
+     * @summary Method to create base path mappings for Api
+     */
+    protected createApiBasePathMapping(): void;
+    /**
+     * @summary Method to create route53 records for Api
+     */
+    protected createApiRouteAssets(): void;
+}