feat(api): Create endpoint for fetching all revisions of a secret

apps/api/src/secret/controller/secret.controller.ts

@@ -101,4 +101,24 @@ export class SecretController {
  environmentId
  )
  }
+
+ @Get(':secretId/revisions/:environmentId')
+ @RequiredApiKeyAuthorities(Authority.READ_SECRET)
+ async getRevisionsOfSecret(
+ @CurrentUser() user: User,
+ @Param('secretId') secretId: string,
+ @Param('environmentId') environmentId: string,
+ @Query('page') page: number = 0,
+ @Query('limit') limit: number = 10,
+ @Query('order') order: string = 'desc'
+ ) {
+ return await this.secretService.getRevisionsOfSecret(
+ user,
+ secretId,
+ environmentId,
+ page,
+ limit,
+ order
+ )
+ }
 }

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

@@ -920,4 +920,108 @@ describe('Secret Controller Tests', () => {
  expect(event.workspaceId).toBe(workspace1.id)
  expect(event.itemId).toBe(secret1.id)
  })
+
+ //revisions test
+ it('should be able to fetch all revisions of secrets', async () => {
+ // create two more entries,totalling three versions
+ // checks if its able to fetch multiple revisions
+ await secretService.updateSecret(user1, secret1.id, {
+ entries: [
+ {
+ value: 'Updated Secret 1 value',
+ environmentId: environment1.id
+ }
+ ]
+ })
+
+ await secretService.updateSecret(user1, secret1.id, {
+ entries: [
+ {
+ value: 'Updated Secret 1 value 2',
+ environmentId: environment1.id
+ }
+ ]
+ })
+
+ const response = await app.inject({
+ method: 'GET',
+ url: `/secret/${secret1.id}/revisions/${environment1.id}`,
+ headers: {
+ 'x-e2e-user-email': user1.email
+ }
+ })
+
+ expect(response.statusCode).toBe(200)
+ expect(response.json().length).toBe(3)
+ })
+
+ it('should return [] if the secret has no revision', async () => {
+ //returns [] if secret has no revision
+ await prisma.secretVersion.deleteMany({
+ where: {
+ secretId: secret1.id
+ }
+ })
+
+ const response = await app.inject({
+ method: 'GET',
+ url: `/secret/${secret1.id}/revisions/${environment1.id}`,
+ headers: {
+ 'x-e2e-user-email': user1.email
+ }
+ })
+
+ expect(response.statusCode).toBe(200)
+ expect(response.json().length).toBe(0)
+ })
+
+ it('should return error if secret doesnt exist', async () => {
+ //return error if secret doesnt exist
+ const secretid = 'nonexistentsecret'
+ const response = await app.inject({
+ method: 'GET',
+ url: `/secret/${secretid}/revisions/${environment1.id}`,
+ headers: {
+ 'x-e2e-user-email': user1.email
+ }
+ })
+
+ expect(response.statusCode).toBe(404)
+ expect(response.json().message).toEqual(
+ `Secret with id ${secretid} not found`
+ )
+ })
+
+ it('should return error if environment doesnt exist', async () => {
+ //return error if environment doesnt exist
+ const environmentid = 'nonexistentenv'
+ const response = await app.inject({
+ method: 'GET',
+ url: `/secret/${secret1.id}/revisions/${environmentid}`,
+ headers: {
+ 'x-e2e-user-email': user1.email
+ }
+ })
+
+ expect(response.statusCode).toBe(404)
+ expect(response.json().message).toEqual(
+ `Environment with id ${environmentid} not found`
+ )
+ })
+
+ it('returns error if secret isnt accessible', async () => {
+ //return error if user has no access to secret
+ const response = await app.inject({
+ method: 'GET',
+ url: `/secret/${secret1.id}/revisions/${environment1.id}`,
+ headers: {
+ 'x-e2e-user-email': user2.email
+ }
+ })
+
+ expect(response.statusCode).toBe(401)
+ expect(response.json().message).toEqual(
+ `User ${user2.id} does not have the required authorities`
+ )
+ })
 })

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

@@ -492,6 +492,45 @@ export class SecretService {
 
  return response
  }
+ async getRevisionsOfSecret(
+ user: User,
+ secretId: Secret['id'],
+ environmentId: Environment['id'],
+ page: number,
+ limit: number,
+ order: string
+ ) {
+ // assign order to variable dynamically
+ const sortOrder = order === 'asc' ? 'asc' : 'desc'
+ //check access to secret
+ await this.authorityCheckerService.checkAuthorityOverSecret({
+ userId: user.id,
+ entity: { id: secretId },
+ authority: Authority.READ_SECRET,
+ prisma: this.prisma
+ })
+
+ await this.authorityCheckerService.checkAuthorityOverEnvironment({
+ userId: user.id,
+ entity: { id: environmentId },
+ authority: Authority.READ_ENVIRONMENT,
+ prisma: this.prisma
+ })
+
+ // get the revisions
+ const revisions = await this.prisma.secretVersion.findMany({
+ where: {
+ secretId: secretId,
+ environmentId: environmentId
+ },
+ skip: page * limit,
+ take: limit,
+ orderBy: {
+ version: sortOrder
+ }
+ })
+ return revisions
+ }
 
  async getAllSecretsOfProject(
  user: User,