feat(apigatewayv2): http api - domain url for a stage

packages/@aws-cdk/aws-apigatewayv2/lib/common/api-mapping.ts

@@ -82,6 +82,11 @@ export class ApiMapping extends Resource implements IApiMapping {
    */
   public readonly mappingKey?: string;
 
+  /**
+   * API domain name
+   */
+  public readonly domainName?: string;
+
   constructor(scope: Construct, id: string, props: ApiMappingProps) {
     super(scope, id);
 
@@ -121,5 +126,6 @@ export class ApiMapping extends Resource implements IApiMapping {
 
     this.apiMappingId = resource.ref;
     this.mappingKey = props.apiMappingKey;
+    this.domainName = props.domainName.name;
   }
 }

packages/@aws-cdk/aws-apigatewayv2/lib/common/base.ts

@@ -36,6 +36,11 @@ export abstract class StageBase extends Resource implements IStage {
   public abstract readonly stageName: string;
   protected abstract readonly baseApi: IApi;
 
+  /**
+   * The created ApiMapping if domain mapping has been added
+   */
+  protected apiMapping?: ApiMapping
+
   /**
    * The URL to this stage.
    */
@@ -45,7 +50,7 @@ export abstract class StageBase extends Resource implements IStage {
    * @internal
    */
   protected _addDomainMapping(domainMapping: DomainMappingOptions) {
-    new ApiMapping(this, `${domainMapping.domainName}${domainMapping.mappingKey}`, {
+    this.apiMapping = new ApiMapping(this, `${domainMapping.domainName}${domainMapping.mappingKey}`, {
       api: this.baseApi,
       domainName: domainMapping.domainName,
       stage: this,

packages/@aws-cdk/aws-apigatewayv2/lib/http/stage.ts

@@ -176,4 +176,18 @@ export class HttpStage extends HttpStageBase {
     const urlPath = this.stageName === DEFAULT_STAGE_NAME ? '' : this.stageName;
     return `https://${this.api.apiId}.execute-api.${s.region}.${s.urlSuffix}/${urlPath}`;
   }
+
+  /**
+   * The custom domain URL to this stage
+   */
+  public get customDomainUrl(): string {
+    if (!this.apiMapping) {
+      throw new Error('customDomainUrl is not available when domain mapping has not been added');
+    }
+    if (!this.apiMapping.domainName) {
+      throw new Error('Unable to build customDomainUrl due to invalid domainName');
+    }
+
+    return `https://${this.apiMapping.domainName}/${this.apiMapping.mappingKey ?? ''}`;
+  }
 }

packages/@aws-cdk/aws-apigatewayv2/test/http/stage.test.ts

@@ -1,8 +1,11 @@
 import { Template } from '@aws-cdk/assertions';
+import { Certificate } from '@aws-cdk/aws-certificatemanager';
 import { Metric } from '@aws-cdk/aws-cloudwatch';
 import { Stack } from '@aws-cdk/core';
-import { HttpApi, HttpStage } from '../../lib';
+import { DomainName, HttpApi, HttpStage } from '../../lib';
 
+const domainName = 'example.com';
+const certArn = 'arn:aws:acm:us-east-1:111111111111:certificate';
 
 describe('HttpStage', () => {
   test('default', () => {
@@ -58,6 +61,69 @@ describe('HttpStage', () => {
     expect(betaStage.url.endsWith('/')).toBe(false);
   });
 
+  test('customDomainUrl returns the correct path', () => {
+    const stack = new Stack();
+    const api = new HttpApi(stack, 'Api', {
+      createDefaultStage: false,
+    });
+
+    const dn = new DomainName(stack, 'DN', {
+      domainName,
+      certificate: Certificate.fromCertificateArn(stack, 'cert', certArn),
+    });
+
+    const stage = new HttpStage(stack, 'DefaultStage', {
+      httpApi: api,
+      domainMapping: {
+        domainName: dn,
+      },
+    });
+
+    expect(stage.customDomainUrl.endsWith(`${domainName}/`)).toBe(true);
+  });
+
+  test('customDomainUrl throws error if domainMapping is not configured', () => {
+    const stack = new Stack();
+    const api = new HttpApi(stack, 'Api', {
+      createDefaultStage: false,
+    });
+
+    const stage = new HttpStage(stack, 'DefaultStage', {
+      httpApi: api,
+    });
+
+    const t = () => {
+      stage.customDomainUrl;
+    };
+
+    expect(t).toThrow('customDomainUrl is not available when domain mapping has not been added');
+  });
+
+  test('customDomainUrl throws error if domainName is invalid', () => {
+    const stack = new Stack();
+    const api = new HttpApi(stack, 'Api', {
+      createDefaultStage: false,
+    });
+
+    const dn = new DomainName(stack, 'DN', {
+      domainName: '',
+      certificate: Certificate.fromCertificateArn(stack, 'cert', certArn),
+    });
+
+    const stage = new HttpStage(stack, 'DefaultStage', {
+      httpApi: api,
+      domainMapping: {
+        domainName: dn,
+      },
+    });
+
+    const t = () => {
+      stage.customDomainUrl;
+    };
+
+    expect(t).toThrow('Unable to build customDomainUrl due to invalid domainName');
+  });
+
   test('get metric', () => {
     // GIVEN
     const stack = new Stack();