feat(site launch): Allow for ops to remove timed out domain associations

.env-example

@@ -26,7 +26,7 @@ export SITE_CREATE_FORM_KEY=""
 # generate your own access key and secret access key from AWS
 export AWS_ACCESS_KEY_ID="" 
 export AWS_SECRET_ACCESS_KEY=""
-export MOCK_AMPLIFY_CREATE_DOMAIN_CALLS="true"
+export MOCK_AMPLIFY_DOMAIN_ASSOCIATION_CALLS="true"
 
 # Required to run end-to-end tests
 export E2E_TEST_REPO="e2e-test-repo"

src/config/config.ts

@@ -172,9 +172,9 @@ const config = convict({
         format: String,
         default: "",
       },
-      mockAmplifyCreateDomainAssociationCalls: {
-        doc: "Mock createDomainAssociation calls to Amplify ",
-        env: "MOCK_AMPLIFY_CREATE_DOMAIN_ASSOCIATION_CALLS",
+      mockAmplifyDomainAssociationCalls: {
+        doc: "Mock domain association calls to Amplify",
+        env: "MOCK_AMPLIFY_DOMAIN_ASSOCIATION_CALLS",
         format: "required-boolean",
         default: true,
       },

src/services/identity/LaunchClient.ts

@@ -7,11 +7,16 @@ import {
   GetDomainAssociationCommandInput as AmplifySDKGetDomainAssociationCommandInput,
   GetDomainAssociationCommandOutput,
   SubDomainSetting,
+  DeleteDomainAssociationCommandInput as AmplifySDKDeleteDomainAssociationCommandInput,
+  DeleteDomainAssociationCommand,
+  NotFoundException,
 } from "@aws-sdk/client-amplify"
 import { SubDomain } from "aws-sdk/clients/amplify"
 
 import { config } from "@config/config"
 
+import { AmplifyError } from "@root/types"
+
 // stricter typing to interact with Amplify SDK
 type CreateDomainAssociationCommandInput = {
   [K in keyof AmplifySDKCreateDomainAssociationCommandInput]: NonNullable<
@@ -25,6 +30,19 @@ type GetDomainAssociationCommandInput = {
   >
 }
 
+type DeleteDomainAssociationCommandInput = {
+  [K in keyof AmplifySDKDeleteDomainAssociationCommandInput]: NonNullable<
+    AmplifySDKDeleteDomainAssociationCommandInput[K]
+  >
+}
+
+export type AmplifyDomainNotFoundException = AmplifyError | NotFoundException
+
+export const isAmplifyDomainNotFoundException = (
+  obj: unknown
+): obj is AmplifyDomainNotFoundException =>
+  obj instanceof AmplifyError || obj instanceof NotFoundException
+
 class LaunchClient {
   private readonly amplifyClient: InstanceType<typeof AmplifyClient>
 
@@ -68,6 +86,14 @@ class LaunchClient {
     domainName,
   })
 
+  createDeleteDomainAssociationCommandInput = (
+    appId: string,
+    domainName: string
+  ): DeleteDomainAssociationCommandInput => ({
+    appId,
+    domainName,
+  })
+
   sendGetDomainAssociationCommand = (
     input: GetDomainAssociationCommandInput
   ): Promise<GetDomainAssociationCommandOutput> => {
@@ -119,7 +145,7 @@ class LaunchClient {
   }
 
   private shouldMockAmplifyDomainCalls(): boolean {
-    return config.get("aws.amplify.mockAmplifyCreateDomainAssociationCalls")
+    return config.get("aws.amplify.mockAmplifyDomainAssociationCalls")
   }
 
   private getSubDomains(
@@ -142,13 +168,33 @@ class LaunchClient {
     return subDomains
   }
 
+  async sendDeleteDomainAssociationCommand(
+    input: DeleteDomainAssociationCommandInput
+  ): Promise<void> {
+    if (this.shouldMockAmplifyDomainCalls()) {
+      this.mockDeleteDomainAssociationOutput(input)
+    }
+    await this.amplifyClient.send(new DeleteDomainAssociationCommand(input))
+  }
+
+  mockDeleteDomainAssociationOutput(
+    input: DeleteDomainAssociationCommandInput
+  ) {
+    if (!this.mockDomainAssociations.has(input.domainName)) {
+      throw new AmplifyError(
+        `NotFoundException: Domain association ${input.domainName} not found.`
+      )
+    }
+    this.mockDomainAssociations.delete(input.domainName)
+  }
+
   private mockGetDomainAssociationOutput(
     input: GetDomainAssociationCommandInput
   ): Promise<GetDomainAssociationCommandOutput> {
     const isSubDomainCreated = true // this is a `get` call, assume domain has already been created
     const subDomainSettings = this.mockDomainAssociations.get(input.domainName)
     if (!subDomainSettings) {
-      throw new Error(
+      throw new AmplifyError(
         `NotFoundException: Domain association ${input.domainName} not found.`
       )
     }

src/services/identity/LaunchesService.ts

@@ -11,7 +11,9 @@ import logger from "@logger/logger"
 import { Deployment, Launch, Repo, User, Redirection } from "@database/models"
 import { RedirectionTypes } from "@root/constants/constants"
 import { AmplifyError } from "@root/types/index"
-import LaunchClient from "@services/identity/LaunchClient"
+import LaunchClient, {
+  isAmplifyDomainNotFoundException,
+} from "@services/identity/LaunchClient"
 
 export type SiteLaunchCreateParams = {
   userId: number
@@ -159,6 +161,41 @@ export class LaunchesService {
       throw siteIdResult.error
     }
 
+    try {
+      // Check if association already exists
+      const getDomainAssociationCommandInput = this.launchClient.createGetDomainAssociationCommandInput(
+        appIdResult.value,
+        domainName
+      )
+
+      const getDomainAssociationResult = await this.launchClient.sendGetDomainAssociationCommand(
+        getDomainAssociationCommandInput
+      )
+      const hasDomainAssociationFailed =
+        getDomainAssociationResult?.domainAssociation?.domainStatus === "FAILED"
+      if (hasDomainAssociationFailed) {
+        // safe to delete and retry
+        const deleteDomainAssociationCommandInput = this.launchClient.createDeleteDomainAssociationCommandInput(
+          appIdResult.value,
+          domainName
+        )
+        await this.launchClient.sendDeleteDomainAssociationCommand(
+          deleteDomainAssociationCommandInput
+        )
+      }
+    } catch (error: unknown) {
+      const isExpectedNotFoundError = isAmplifyDomainNotFoundException(error)
+      if (!isExpectedNotFoundError) {
+        return err(
+          new AmplifyError(
+            `Unable to connect to Amplify for: ${repoName}, ${error}`,
+            repoName,
+            appIdResult.value
+          )
+        )
+      }
+    }
+
     const launchAppOptions = this.launchClient.createDomainAssociationCommandInput(
       appIdResult.value,
       domainName,

src/services/infra/InfraService.ts

@@ -228,8 +228,9 @@ export default class InfraService {
       )
 
       // Get DNS records from Amplify
-      const isTestEnv =
-        config.get("env") === "test" || config.get("env") === "dev"
+      const isTestEnv = config.get(
+        "aws.amplify.mockAmplifyDomainAssociationCalls"
+      )
       // since we mock values during development, we don't have to await for the dns records
       if (!isTestEnv) {
         /**