Store DNS deployment records data in Deployment entity

packages/backend/src/entity/Deployment.ts

@@ -105,15 +105,24 @@ export class Deployment {
   @Column('varchar', { nullable: true })
     applicationDeploymentRequestId!: string | null;
 
+  @Column('varchar', { nullable: true })
+    dnsDeploymentRequestId!: string | null;
+
   @Column('simple-json', { nullable: true })
     applicationDeploymentRequestData!: ApplicationDeploymentRequest | null;
 
   @Column('varchar', { nullable: true })
     applicationDeploymentRecordId!: string | null;
 
+  @Column('varchar', { nullable: true })
+    dnsDeploymentRecordId!: string | null;
+
   @Column('simple-json', { nullable: true })
     applicationDeploymentRecordData!: AppDeploymentRecordAttributes | null;
 
+  @Column('simple-json', { nullable: true })
+    dnsDeploymentRecordData!: AppDeploymentRecordAttributes | null;
+
   @Column('varchar', { nullable: true })
     applicationDeploymentRemovalRequestId!: string | null;
 

packages/backend/src/registry.ts

@@ -387,8 +387,8 @@ export class Registry {
     return records.filter((record: AppDeploymentRecord) =>
       deployments.some(
         (deployment) =>
-          deployment.applicationDeploymentRequestId === record.attributes.request &&
+          deployment.applicationDeploymentRequestId === record.attributes.request ||
-          record.attributes.url.includes(deployment.id)
+          deployment.dnsDeploymentRequestId === record.attributes.request
       )
     );
   }
@@ -444,9 +444,9 @@ export class Registry {
   }
 
   /**
-   * Fetch deployment DNS Records by Id
+ * Fetch deployment DNS record by Id
  */
-    async getDNSRecordsById(id: string): Promise<DNSRecord[]> {
+  async getDNSRecordById(id: string): Promise<DNSRecord[]> {
     return this.registry.getRecordsByIds([id]);
   }
 

packages/backend/src/service.ts

@@ -185,23 +185,28 @@ export class Service {
       },
     });
 
-    const recordToDeploymentsMap = deployments.reduce(
+    const requestIdToRecordsMap = records.reduce(
-      (acc: { [key: string]: Deployment }, deployment) => {
+      (acc: { [key: string]: AppDeploymentRecord }, record) => {
-        acc[deployment.applicationDeploymentRequestId!] = deployment;
+        acc[record.attributes.request] = record;
         return acc;
       },
       {},
     );
 
     // Update deployment data for ApplicationDeploymentRecords
-    const deploymentUpdatePromises = records.map(async (record) => {
+    const deploymentUpdatePromises = deployments.map(async (deployment) => {
-      const deployment = recordToDeploymentsMap[record.attributes.request];
+      const applicationDeploymentRecord = requestIdToRecordsMap[deployment.applicationDeploymentRequestId!]
+      const dnsDeploymentRecord = requestIdToRecordsMap[deployment.dnsDeploymentRequestId!]
+
+      if (!applicationDeploymentRecord || !dnsDeploymentRecord) {
+        return;
+      }
 
       if (!deployment.project) {
         log(`Project ${deployment.projectId} not found`);
         return;
       } else {
-        const dnsRecords = await this.laconicRegistry.getDNSRecordsById(record.attributes.dns);
+        const dnsRecords = await this.laconicRegistry.getDNSRecordById(applicationDeploymentRecord.attributes.dns);
 
         const dnsRecordData: DNSRecordAttributes = {
           name: dnsRecords[0].attributes.name,
@@ -211,9 +216,11 @@ export class Service {
           version: dnsRecords[0].attributes.version,
         }
 
-        deployment.applicationDeploymentRecordId = record.id;
+        deployment.applicationDeploymentRecordId = applicationDeploymentRecord.id;
-        deployment.applicationDeploymentRecordData = record.attributes;
+        deployment.dnsDeploymentRecordId = dnsDeploymentRecord.id;
-        deployment.url = record.attributes.url;
+        deployment.applicationDeploymentRecordData = applicationDeploymentRecord.attributes;
+        deployment.dnsDeploymentRecordData = dnsDeploymentRecord.attributes;
+        deployment.url = applicationDeploymentRecord.attributes.url;
         deployment.status = DeploymentStatus.Ready;
         deployment.isCurrent = deployment.environment === Environment.Production;
         deployment.dnsRecordData = dnsRecordData;
@@ -233,18 +240,12 @@ export class Service {
         }
 
         log(
-          `Updated deployment ${deployment.id} with URL ${record.attributes.url}`,
+          `Updated deployment ${deployment.id} with URL ${applicationDeploymentRecord.attributes.url}`,
         );
       }
-    });
-
-    await Promise.all(deploymentUpdatePromises);
-
-    // Get deployments that are in production environment
-    const prodDeployments = Object.values(recordToDeploymentsMap).filter(deployment => deployment.isCurrent);
 
       // Set the isCurrent state to false for the old deployments
-    for (const deployment of prodDeployments) {
+      if (deployment.isCurrent) {
         const projectDeployments = await this.db.getDeploymentsByProjectId(deployment.projectId);
         const oldDeployments = projectDeployments
           .filter(projectDeployment => projectDeployment.deployer.deployerLrn === deployment.deployer.deployerLrn && projectDeployment.id !== deployment.id);
@@ -255,6 +256,7 @@ export class Service {
           );
         }
       }
+    });
 
     await Promise.all(deploymentUpdatePromises);
   }
@@ -666,10 +668,11 @@ export class Service {
     const domain = await this.db.getOldestDomainByProjectId(data.project!.id!);
 
     // To set project DNS
+    let dnsDeploymentRequestId = null;
     if (data.environment === Environment.Production) {
       // On deleting deployment later, project DNS deployment is also deleted
       // So publish project DNS deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
-      await this.laconicRegistry.createApplicationDeploymentRequest({
+      const dnsRequest = await this.laconicRegistry.createApplicationDeploymentRequest({
         deployment: newDeployment,
         appName: repo,
         repository: repoUrl,
@@ -682,6 +685,7 @@ export class Service {
         requesterAddress: address,
         publicKey: deployer!.publicKey!
       });
+      dnsDeploymentRequestId = dnsRequest.applicationDeploymentRequestId;
     }
 
     const { applicationDeploymentRequestId, applicationDeploymentRequestData } =
@@ -702,6 +706,7 @@ export class Service {
     await this.db.updateDeploymentById(newDeployment.id, {
       applicationDeploymentRequestId,
       applicationDeploymentRequestData,
+      dnsDeploymentRequestId
     });
 
     return newDeployment;