refactor(api): Update return type while fetching secrets and variables

apps/api/src/secret/secret.e2e.spec.ts

@@ -840,8 +840,9 @@ describe('Secret Controller Tests', () => {
 
     expect(response.statusCode).toBe(200)
     expect(response.json().length).toBe(1)
-    const secret = response.json()[0]
-    expect(secret.secrets[0].versions[0].value).toEqual('Secret 1 value')
+    const envsecret = response.json()[0]
+    expect(envsecret.environment).toHaveProperty('id')
+    expect(envsecret.environment).toHaveProperty('name')
   })
 
   it('should not be able to fetch all secrets decrypted if the project does not store the private key', async () => {

apps/api/src/secret/secret.types.ts

@@ -16,4 +16,10 @@ export interface SecretWithEnvironment extends Secret {
   environment: Environment
 }
 
+export type SecretsByEnvironment = {
+  environment: { id: string; name: string }
+  secrets: any[]
+}
 export type SecretWithProjectAndVersion = SecretWithProject & SecretWithVersion
+export type SecretWithVersionAndEnvironment = SecretWithVersion &
+  SecretWithEnvironment

apps/api/src/secret/service/secret.service.ts

@@ -26,9 +26,12 @@
 import { addHoursToDate } from '../../common/add-hours-to-date'
 import { encrypt } from '../../common/encrypt'
 import {
+  SecretWithEnvironment,
   SecretWithProject,
   SecretWithProjectAndVersion,
-  SecretWithVersion
+  SecretWithVersion,
+  SecretWithVersionAndEnvironment,
+  SecretsByEnvironment
 } from '../secret.types'
 import createEvent from '../../common/create-event'
 import getDefaultEnvironmentOfProject from '../../common/get-default-project-environment'
@@ -488,7 +491,7 @@
       orderBy: {
         [sort]: order
       }
-    })) as SecretWithVersion[]
+    })) as unknown as SecretWithVersionAndEnvironment[]
 
     if (decryptValue) {
       for (const secret of secrets) {
@@ -502,62 +505,28 @@
         }
       }
     }
-
     // Group secrets by environment
-    const secretsByEnvironment = await secrets.reduce(
-      async (accPromise, secret) => {
-        const acc = await accPromise
-        const environmentName = await this.getEnvironmentName(
-          secret.environmentId
-        )
-
-        if (!acc[secret.environmentId]) {
-          acc[secret.environmentId] = {
-            environmentName: environmentName,
-            environmentId: secret.environmentId,
+    const secretsByEnvironment = secrets.reduce((acc, secret) => {
+      const { environment } = secret
+      if (environment) {
+        const { id, name } = environment
+        if (!acc[id]) {
+          acc[id] = {
+            environment: { id, name },
             secrets: []
           }
         }
-
-        acc[secret.environmentId].secrets.push(secret)
-        return acc
-      },
-      Promise.resolve({})
-    )
+        acc[id].secrets.push(secret)
+      }
+      return acc
+    }, {} as SecretsByEnvironment)
 
     // Convert the result to an array
     const clusteredSecrets = Object.values(secretsByEnvironment)
 
-    console.log(clusteredSecrets)
-
     return clusteredSecrets
   }
 
-  private async getEnvironmentName(
-    environmentId: string
-  ): Promise<string | null> {
-    try {
-      // Fetch the environment using its unique ID
-      const environment = await this.prisma.environment.findUnique({
-        where: {
-          id: environmentId
-        }
-      })
-
-      // Check if the environment exists
-      if (environment) {
-        // Access and return the name property
-        return environment.name
-      } else {
-        console.log('Environment not found')
-        return null
-      }
-    } catch (error) {
-      console.error('Error fetching environment:', error)
-      return null
-    }
-  }
-
   private async secretExists(
     secretName: Secret['name'],
     environmentId: Environment['id']

apps/api/src/variable/service/variable.service.ts

@@ -29,7 +29,8 @@ import createApproval from '../../common/create-approval'
 import { UpdateVariableMetadata } from '../../approval/approval.types'
 import {
   VariableWithProject,
-  VariableWithProjectAndVersion
+  VariableWithProjectAndVersion,
+  VariablesByEnvironment
 } from '../variable.types'
 import { RedisClientType } from 'redis'
 import { REDIS_CLIENT } from '../../provider/redis.provider'
@@ -413,79 +414,70 @@ export class VariableService {
     sort: string,
     order: string,
     search: string
-  ): Promise<
-    { environmentName: string; environmentId: string; variables: any[] }[]
-  > {
-    try {
-      // Check if the user has the required authorities in the project
-      await this.authorityCheckerService.checkAuthorityOverProject({
-        userId: user.id,
-        entity: { id: projectId },
-        authority: Authority.READ_VARIABLE,
-        prisma: this.prisma
-      })
+  ): Promise<VariablesByEnvironment[]> {
+    // Check if the user has the required authorities in the project
+    await this.authorityCheckerService.checkAuthorityOverProject({
+      userId: user.id,
+      entity: { id: projectId },
+      authority: Authority.READ_VARIABLE,
+      prisma: this.prisma
+    })
 
-      const variables = await this.prisma.variable.findMany({
-        where: {
-          projectId,
-          pendingCreation: false,
-          name: {
-            contains: search
-          }
-        },
-        include: {
-          versions: {
-            orderBy: {
-              version: 'desc'
-            },
-            take: 1
-          },
-          lastUpdatedBy: {
-            select: {
-              id: true,
-              name: true
-            }
+    const variables = await this.prisma.variable.findMany({
+      where: {
+        projectId,
+        pendingCreation: false,
+        name: {
+          contains: search
+        }
+      },
+      include: {
+        versions: {
+          orderBy: {
+            version: 'desc'
           },
-          environment: {
-            select: {
-              id: true,
-              name: true
-            }
+          take: 1
+        },
+        lastUpdatedBy: {
+          select: {
+            id: true,
+            name: true
           }
         },
-        skip: page * limit,
-        take: limit,
-        orderBy: {
-          [sort]: order
-        }
-      })
-
-      // Group variables by environment
-      const variablesByEnvironment: {
-        [key: string]: {
-          environmentName: string
-          environmentId: string
-          variables: any[]
-        }
-      } = {}
-      for (const variable of variables) {
-        const { id, name } = variable.environment
-        if (!variablesByEnvironment[id]) {
-          variablesByEnvironment[id] = {
-            environmentName: name,
-            environmentId: id,
-            variables: []
+        environment: {
+          select: {
+            id: true,
+            name: true
           }
         }
-        variablesByEnvironment[id].variables.push(variable)
+      },
+      skip: page * limit,
+      take: limit,
+      orderBy: {
+        [sort]: order
       }
+    })
 
-      // Convert the object to an array and return
-      return Object.values(variablesByEnvironment)
-    } catch (error) {
-      console.error('Error fetching variables:', error)
-      throw error // Or handle the error as per your application's requirement
+    // Group variables by environment
+    const variablesByEnvironment: {
+      [key: string]: {
+        environment: { id: string; name: string }
+        variables: any[]
+      }
+    } = {}
+    for (const variable of variables) {
+      const { id, name } = variable.environment
+      if (!variablesByEnvironment[id]) {
+        variablesByEnvironment[id] = {
+          environment: { id, name },
+          variables: []
+        }
+      }
+      variablesByEnvironment[id].variables.push(variable)
     }
+
+    // Convert the object to an array and return
+    return Object.values(variablesByEnvironment)
   }
 
   private async variableExists(

apps/api/src/variable/variable.e2e.spec.ts

@@ -774,6 +774,9 @@ describe('Variable Controller Tests', () => {
 
     expect(response.statusCode).toBe(200)
     expect(response.json().length).toBe(1)
+    const envvariable = response.json()[0]
+    expect(envvariable.environment).toHaveProperty('id')
+    expect(envvariable.environment).toHaveProperty('name')
   })
 
   it('should not be able to fetch all variables if the user has no access to the project', async () => {

apps/api/src/variable/variable.types.ts

@@ -16,5 +16,10 @@ export interface VariableWithEnvironment extends Variable {
   environment: Environment
 }
 
+export type VariablesByEnvironment = {
+  environment: { id: string; name: string }
+  variables: any[]
+}
+
 export type VariableWithProjectAndVersion = VariableWithProject &
   VariableWithVersion